X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Ffields.c;h=412b7fdef065cc3adf0cf80bd3d35f32a5d811bb;hb=e25dc75977dad34abd4340bd5478f9f3864a6ffd;hp=3ca57bb017ba097bce5517fd17735a1cbf08c168;hpb=918be0053a529d1e7f93981388a7672534eb5af8;p=babeltrace.git diff --git a/formats/ctf/ir/fields.c b/formats/ctf/ir/fields.c index 3ca57bb0..412b7fde 100644 --- a/formats/ctf/ir/fields.c +++ b/formats/ctf/ir/fields.c @@ -161,6 +161,19 @@ void bt_ctf_field_array_freeze(struct bt_ctf_field *); static void bt_ctf_field_sequence_freeze(struct bt_ctf_field *); +static +bool bt_ctf_field_generic_is_set(struct bt_ctf_field *); +static +bool bt_ctf_field_structure_is_set(struct bt_ctf_field *); +static +bool bt_ctf_field_variant_is_set(struct bt_ctf_field *); +static +bool bt_ctf_field_enumeration_is_set(struct bt_ctf_field *); +static +bool bt_ctf_field_array_is_set(struct bt_ctf_field *); +static +bool bt_ctf_field_sequence_is_set(struct bt_ctf_field *); + static int increase_packet_size(struct ctf_stream_pos *pos); @@ -254,6 +267,18 @@ void (* const field_freeze_funcs[])(struct bt_ctf_field *) = { [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_freeze, }; +static +bool (* const field_is_set_funcs[])(struct bt_ctf_field *) = { + [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_is_set, + [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_is_set, + [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_is_set, + [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_is_set, + [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_is_set, + [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_is_set, + [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_is_set, + [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_generic_is_set, +}; + struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type) { struct bt_ctf_field *field = NULL; @@ -788,6 +813,27 @@ end: return current_field; } +struct bt_ctf_field *bt_ctf_field_variant_get_tag( + struct bt_ctf_field *variant_field) +{ + struct bt_ctf_field *tag = NULL; + struct bt_ctf_field_variant *variant; + + if (!variant_field || + bt_ctf_field_type_get_type_id(variant_field->type) != + BT_CTF_TYPE_ID_VARIANT) { + goto end; + } + + variant = container_of(variant_field, struct bt_ctf_field_variant, + parent); + if (variant->tag) { + tag = bt_get(variant->tag); + } +end: + return tag; +} + struct bt_ctf_field *bt_ctf_field_enumeration_get_container( struct bt_ctf_field *field) { @@ -820,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; @@ -828,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) { @@ -842,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: @@ -872,6 +926,7 @@ error_put_container_type: error_put_container: bt_put(container); end: + bt_put(iter); return name; } @@ -928,8 +983,8 @@ int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *field, } size = integer_type->declaration.len; - min_value = -((int64_t)1 << (size - 1)); - max_value = ((int64_t)1 << (size - 1)) - 1; + min_value = -(1ULL << (size - 1)); + max_value = (1ULL << (size - 1)) - 1; if (value < min_value || value > max_value) { ret = -1; goto end; @@ -994,7 +1049,7 @@ int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *field, } size = integer_type->declaration.len; - max_value = (size == 64) ? UINT64_MAX : ((uint64_t)1 << size) - 1; + max_value = (size == 64) ? UINT64_MAX : ((uint64_t) 1 << size) - 1; if (value > max_value) { ret = -1; goto end; @@ -1222,6 +1277,27 @@ end: return ret; } + +BT_HIDDEN +bool bt_ctf_field_is_set(struct bt_ctf_field *field) +{ + bool is_set = false; + enum bt_ctf_type_id type_id; + + if (!field) { + goto end; + } + + type_id = bt_ctf_field_type_get_type_id(field->type); + if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) { + goto end; + } + + is_set = field_is_set_funcs[type_id](field); +end: + return is_set; +} + struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field) { int ret; @@ -1571,6 +1647,15 @@ int bt_ctf_field_structure_validate(struct bt_ctf_field *field) for (i = 0; i < structure->fields->len; i++) { ret = bt_ctf_field_validate(structure->fields->pdata[i]); if (ret) { + const char *name; + struct bt_ctf_field_type *field_type = + bt_ctf_field_get_type(field); + + (void) bt_ctf_field_type_structure_get_field(field_type, + &name, NULL, i); + fprintf(stderr, "Field %s failed validation\n", + name ? name : "NULL"); + bt_put(field_type); goto end; } } @@ -1611,6 +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 array field #%zu\n", i); goto end; } } @@ -1634,6 +1720,7 @@ int bt_ctf_field_sequence_validate(struct bt_ctf_field *field) for (i = 0; i < sequence->elements->len; i++) { ret = bt_ctf_field_validate(sequence->elements->pdata[i]); if (ret) { + fprintf(stderr, "Failed to validate sequence field #%zu\n", i); goto end; } } @@ -1909,6 +1996,15 @@ int bt_ctf_field_structure_serialize(struct bt_ctf_field *field, ret = bt_ctf_field_serialize(field, pos); if (ret) { + const char *name; + struct bt_ctf_field_type *field_type = + bt_ctf_field_get_type(field); + + (void) bt_ctf_field_type_structure_get_field(field_type, + &name, NULL, i); + fprintf(stderr, "Field %s failed to serialize\n", + name ? name : "NULL"); + bt_put(field_type); break; } } @@ -1939,6 +2035,7 @@ int bt_ctf_field_array_serialize(struct bt_ctf_field *field, ret = bt_ctf_field_serialize( g_ptr_array_index(array->elements, i), pos); if (ret) { + fprintf(stderr, "Failed to serialize array element #%zu\n", i); goto end; } } @@ -1959,6 +2056,7 @@ int bt_ctf_field_sequence_serialize(struct bt_ctf_field *field, ret = bt_ctf_field_serialize( g_ptr_array_index(sequence->elements, i), pos); if (ret) { + fprintf(stderr, "Failed to serialize sequence element #%zu\n", i); goto end; } } @@ -2339,12 +2437,128 @@ void bt_ctf_field_sequence_freeze(struct bt_ctf_field *field) BT_HIDDEN void bt_ctf_field_freeze(struct bt_ctf_field *field) { + enum bt_ctf_type_id type_id; + if (!field) { goto end; } - field_freeze_funcs[bt_ctf_field_get_type_id(field)](field); + type_id = bt_ctf_field_get_type_id(field); + if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || + type_id >= BT_CTF_NR_TYPE_IDS) { + goto end; + } + field_freeze_funcs[type_id](field); end: return; } + +static +bool bt_ctf_field_generic_is_set(struct bt_ctf_field *field) +{ + return field && field->payload_set; +} + +static +bool bt_ctf_field_enumeration_is_set(struct bt_ctf_field *field) +{ + bool is_set = false; + struct bt_ctf_field_enumeration *enumeration; + + if (!field) { + goto end; + } + + enumeration = container_of(field, struct bt_ctf_field_enumeration, + parent); + if (!enumeration->payload) { + goto end; + } + + is_set = bt_ctf_field_is_set(enumeration->payload); +end: + return is_set; +} + +static +bool bt_ctf_field_structure_is_set(struct bt_ctf_field *field) +{ + bool is_set = false; + size_t i; + struct bt_ctf_field_structure *structure; + + if (!field) { + goto end; + } + + structure = container_of(field, struct bt_ctf_field_structure, parent); + for (i = 0; i < structure->fields->len; i++) { + is_set = bt_ctf_field_is_set(structure->fields->pdata[i]); + if (!is_set) { + goto end; + } + } +end: + return is_set; +} + +static +bool bt_ctf_field_variant_is_set(struct bt_ctf_field *field) +{ + bool is_set = false; + struct bt_ctf_field_variant *variant; + + if (!field) { + goto end; + } + + variant = container_of(field, struct bt_ctf_field_variant, parent); + is_set = bt_ctf_field_is_set(variant->payload); +end: + return is_set; +} + +static +bool bt_ctf_field_array_is_set(struct bt_ctf_field *field) +{ + size_t i; + bool is_set = false; + struct bt_ctf_field_array *array; + + if (!field) { + goto end; + } + + array = container_of(field, struct bt_ctf_field_array, parent); + for (i = 0; i < array->elements->len; i++) { + is_set = bt_ctf_field_is_set(array->elements->pdata[i]); + if (!is_set) { + goto end; + } + } +end: + return is_set; +} + +static +bool bt_ctf_field_sequence_is_set(struct bt_ctf_field *field) +{ + size_t i; + bool is_set = false; + struct bt_ctf_field_sequence *sequence; + + if (!field) { + goto end; + } + + sequence = container_of(field, struct bt_ctf_field_sequence, parent); + for (i = 0; i < sequence->elements->len; i++) { + is_set = bt_ctf_field_validate(sequence->elements->pdata[i]); + if (!is_set) { + goto end; + } + } +end: + return is_set; +}