projects
/
babeltrace.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
Unify reference counting using a common bt_object base
[babeltrace.git]
/
formats
/
ctf
/
ir
/
event-types.c
diff --git
a/formats/ctf/ir/event-types.c
b/formats/ctf/ir/event-types.c
index b336889b029efb208c525a17fb32e44b4301f048..74fa30473939440acf5266ce8353dabe7925827a 100644
(file)
--- a/
formats/ctf/ir/event-types.c
+++ b/
formats/ctf/ir/event-types.c
@@
-29,8
+29,11
@@
#include <babeltrace/ctf-writer/event-types.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/ctf-writer/event-types.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
#include <babeltrace/ctf-ir/utils.h>
+#include <babeltrace/ref.h>
#include <babeltrace/ctf-ir/clock.h>
#include <babeltrace/ctf-writer/writer-internal.h>
#include <babeltrace/ctf-ir/clock.h>
#include <babeltrace/ctf-writer/writer-internal.h>
+#include <babeltrace/object-internal.h>
+#include <babeltrace/ref.h>
#include <babeltrace/compiler.h>
#include <babeltrace/endian.h>
#include <float.h>
#include <babeltrace/compiler.h>
#include <babeltrace/endian.h>
#include <float.h>
@@
-52,26
+55,26
@@
struct range_overlap_query {
};
static
};
static
-void bt_ctf_field_type_destroy(struct bt_
ctf_ref
*);
+void bt_ctf_field_type_destroy(struct bt_
object
*);
static
static
-void bt_ctf_field_type_integer_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_integer_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_structure_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_structure_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_variant_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_variant_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_array_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_array_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_sequence_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_sequence_destroy(struct bt_ctf_
field_type
*);
static
static
-void bt_ctf_field_type_string_destroy(struct bt_ctf_
ref
*);
+void bt_ctf_field_type_string_destroy(struct bt_ctf_
field_type
*);
static
static
-void (* const type_destroy_funcs[])(struct bt_ctf_
ref
*) = {
+void (* const type_destroy_funcs[])(struct bt_ctf_
field_type
*) = {
[CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_destroy,
[CTF_TYPE_ENUM] =
bt_ctf_field_type_enumeration_destroy,
[CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_destroy,
[CTF_TYPE_ENUM] =
bt_ctf_field_type_enumeration_destroy,
@@
-235,10
+238,7
@@
void destroy_enumeration_mapping(struct enumeration_mapping *mapping)
static
void destroy_structure_field(struct structure_field *field)
{
static
void destroy_structure_field(struct structure_field *field)
{
- if (field->type) {
- bt_ctf_field_type_put(field->type);
- }
-
+ bt_put(field->type);
g_free(field);
}
g_free(field);
}
@@
-291,19
+291,23
@@
gint compare_enumeration_mappings_unsigned(struct enumeration_mapping **a,
}
static
}
static
-void bt_ctf_field_type_init(struct bt_ctf_field_type *type)
+void bt_ctf_field_type_init(struct bt_ctf_field_type *type
, int init_bo
)
{
enum ctf_type_id type_id = type->declaration->id;
{
enum ctf_type_id type_id = type->declaration->id;
- int ret;
assert(type && (type_id > CTF_TYPE_UNKNOWN) &&
(type_id < NR_CTF_TYPES));
assert(type && (type_id > CTF_TYPE_UNKNOWN) &&
(type_id < NR_CTF_TYPES));
- bt_
ctf_ref_init(&type->ref_count
);
+ bt_
object_init(type, bt_ctf_field_type_destroy
);
type->freeze = type_freeze_funcs[type_id];
type->serialize = type_serialize_funcs[type_id];
type->freeze = type_freeze_funcs[type_id];
type->serialize = type_serialize_funcs[type_id];
- ret = bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_NATIVE);
- assert(!ret);
+
+ if (init_bo) {
+ int ret = bt_ctf_field_type_set_byte_order(type,
+ BT_CTF_BYTE_ORDER_NATIVE);
+ assert(!ret);
+ }
+
type->declaration->alignment = 1;
}
type->declaration->alignment = 1;
}
@@
-330,7
+334,7
@@
int add_structure_field(GPtrArray *fields,
goto end;
}
goto end;
}
- bt_
ctf_field_type_
get(field_type);
+ bt_get(field_type);
field->name = name_quark;
field->type = field_type;
g_hash_table_insert(field_name_to_index,
field->name = name_quark;
field->type = field_type;
g_hash_table_insert(field_name_to_index,
@@
-342,23
+346,19
@@
end:
}
static
}
static
-void bt_ctf_field_type_destroy(struct bt_
ctf_ref *ref
)
+void bt_ctf_field_type_destroy(struct bt_
object *obj
)
{
struct bt_ctf_field_type *type;
enum ctf_type_id type_id;
{
struct bt_ctf_field_type *type;
enum ctf_type_id type_id;
- if (!ref) {
- return;
- }
-
- type = container_of(ref, struct bt_ctf_field_type, ref_count);
+ type = container_of(obj, struct bt_ctf_field_type, base);
type_id = type->declaration->id;
if (type_id <= CTF_TYPE_UNKNOWN ||
type_id >= NR_CTF_TYPES) {
return;
}
type_id = type->declaration->id;
if (type_id <= CTF_TYPE_UNKNOWN ||
type_id >= NR_CTF_TYPES) {
return;
}
- type_destroy_funcs[type_id](
ref
);
+ type_destroy_funcs[type_id](
type
);
}
BT_HIDDEN
}
BT_HIDDEN
@@
-424,7
+424,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size)
integer->declaration.len = size;
integer->declaration.base = BT_CTF_INTEGER_BASE_DECIMAL;
integer->declaration.encoding = CTF_STRING_NONE;
integer->declaration.len = size;
integer->declaration.base = BT_CTF_INTEGER_BASE_DECIMAL;
integer->declaration.encoding = CTF_STRING_NONE;
- bt_ctf_field_type_init(&integer->parent);
+ bt_ctf_field_type_init(&integer->parent
, TRUE
);
return &integer->parent;
}
return &integer->parent;
}
@@
-571,9
+571,7
@@
struct bt_ctf_clock *bt_ctf_field_type_integer_get_mapped_clock(
integer = container_of(type, struct bt_ctf_field_type_integer, parent);
clock = integer->mapped_clock;
integer = container_of(type, struct bt_ctf_field_type_integer, parent);
clock = integer->mapped_clock;
- if (clock) {
- bt_ctf_clock_get(clock);
- }
+ bt_get(clock);
end:
return clock;
}
end:
return clock;
}
@@
-591,14
+589,8
@@
int bt_ctf_field_type_integer_set_mapped_clock(
}
integer = container_of(type, struct bt_ctf_field_type_integer, parent);
}
integer = container_of(type, struct bt_ctf_field_type_integer, parent);
- if (integer->mapped_clock) {
- bt_ctf_clock_put(integer->mapped_clock);
- }
-
- if (clock) {
- bt_ctf_clock_get(clock);
- }
-
+ bt_put(integer->mapped_clock);
+ bt_get(clock);
integer->mapped_clock = clock;
end:
return ret;
integer->mapped_clock = clock;
end:
return ret;
@@
-624,11
+616,11
@@
struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create(
enumeration->parent.declaration = &enumeration->declaration.p;
enumeration->parent.declaration->id = CTF_TYPE_ENUM;
enumeration->parent.declaration = &enumeration->declaration.p;
enumeration->parent.declaration->id = CTF_TYPE_ENUM;
- bt_
ctf_field_type_
get(integer_container_type);
+ bt_get(integer_container_type);
enumeration->container = integer_container_type;
enumeration->entries = g_ptr_array_new_with_free_func(
(GDestroyNotify)destroy_enumeration_mapping);
enumeration->container = integer_container_type;
enumeration->entries = g_ptr_array_new_with_free_func(
(GDestroyNotify)destroy_enumeration_mapping);
- bt_ctf_field_type_init(&enumeration->parent);
+ bt_ctf_field_type_init(&enumeration->parent
, FALSE
);
return &enumeration->parent;
error:
g_free(enumeration);
return &enumeration->parent;
error:
g_free(enumeration);
@@
-652,7
+644,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_enumeration_get_container_type(
enumeration_type = container_of(type,
struct bt_ctf_field_type_enumeration, parent);
container_type = enumeration_type->container;
enumeration_type = container_of(type,
struct bt_ctf_field_type_enumeration, parent);
container_type = enumeration_type->container;
- bt_
ctf_field_type_
get(container_type);
+ bt_get(container_type);
end:
return container_type;
}
end:
return container_type;
}
@@
-1033,7
+1025,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void)
floating_point->mantissa.p.alignment = 1;
floating_point->exp.p.alignment = 1;
floating_point->mantissa.p.alignment = 1;
floating_point->exp.p.alignment = 1;
- bt_ctf_field_type_init(&floating_point->parent);
+ bt_ctf_field_type_init(&floating_point->parent
, TRUE
);
end:
return floating_point ? &floating_point->parent : NULL;
}
end:
return floating_point ? &floating_point->parent : NULL;
}
@@
-1144,7
+1136,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void)
structure->fields = g_ptr_array_new_with_free_func(
(GDestroyNotify)destroy_structure_field);
structure->field_name_to_index = g_hash_table_new(NULL, NULL);
structure->fields = g_ptr_array_new_with_free_func(
(GDestroyNotify)destroy_structure_field);
structure->field_name_to_index = g_hash_table_new(NULL, NULL);
- bt_ctf_field_type_init(&structure->parent);
+ bt_ctf_field_type_init(&structure->parent
, TRUE
);
return &structure->parent;
error:
return NULL;
return &structure->parent;
error:
return NULL;
@@
-1217,7
+1209,7
@@
int bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *type,
field = g_ptr_array_index(structure->fields, index);
if (field_type) {
*field_type = field->type;
field = g_ptr_array_index(structure->fields, index);
if (field_type) {
*field_type = field->type;
- bt_
ctf_field_type_
get(field->type);
+ bt_get(field->type);
}
if (field_name) {
*field_name = g_quark_to_string(field->name);
}
if (field_name) {
*field_name = g_quark_to_string(field->name);
@@
-1254,7
+1246,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_structure_get_field_type_by_name(
field = structure->fields->pdata[index];
field_type = field->type;
field = structure->fields->pdata[index];
field_type = field->type;
- bt_
ctf_field_type_
get(field_type);
+ bt_get(field_type);
end:
return field_type;
}
end:
return field_type;
}
@@
-1278,14
+1270,16
@@
struct bt_ctf_field_type *bt_ctf_field_type_variant_create(
variant->tag_name = g_string_new(tag_name);
variant->field_name_to_index = g_hash_table_new(NULL, NULL);
variant->fields = g_ptr_array_new_with_free_func(
variant->tag_name = g_string_new(tag_name);
variant->field_name_to_index = g_hash_table_new(NULL, NULL);
variant->fields = g_ptr_array_new_with_free_func(
- (GDestroyNotify)destroy_structure_field);
+ (GDestroyNotify)
destroy_structure_field);
if (enum_tag) {
if (enum_tag) {
- bt_
ctf_field_type_
get(enum_tag);
+ bt_get(enum_tag);
variant->tag = container_of(enum_tag,
struct bt_ctf_field_type_enumeration, parent);
}
variant->tag = container_of(enum_tag,
struct bt_ctf_field_type_enumeration, parent);
}
- bt_ctf_field_type_init(&variant->parent);
+ bt_ctf_field_type_init(&variant->parent, TRUE);
+ /* A variant's alignment is undefined */
+ variant->parent.declaration->alignment = 0;
return &variant->parent;
error:
return NULL;
return &variant->parent;
error:
return NULL;
@@
-1307,7
+1301,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_variant_get_tag_type(
}
tag_type = &variant->tag->parent;
}
tag_type = &variant->tag->parent;
- bt_
ctf_field_type_
get(tag_type);
+ bt_get(tag_type);
end:
return tag_type;
}
end:
return tag_type;
}
@@
-1428,7
+1422,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_by_name(
field = g_ptr_array_index(variant->fields, index);
field_type = field->type;
field = g_ptr_array_index(variant->fields, index);
field_type = field->type;
- bt_
ctf_field_type_
get(field_type);
+ bt_get(field_type);
end:
return field_type;
}
end:
return field_type;
}
@@
-1497,7
+1491,7
@@
int bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *type,
field = g_ptr_array_index(variant->fields, index);
if (field_type) {
*field_type = field->type;
field = g_ptr_array_index(variant->fields, index);
if (field_type) {
*field_type = field->type;
- bt_
ctf_field_type_
get(field->type);
+ bt_get(field->type);
}
if (field_name) {
*field_name = g_quark_to_string(field->name);
}
if (field_name) {
*field_name = g_quark_to_string(field->name);
@@
-1525,10
+1519,10
@@
struct bt_ctf_field_type *bt_ctf_field_type_array_create(
array->parent.declaration = &array->declaration.p;
array->parent.declaration->id = CTF_TYPE_ARRAY;
array->parent.declaration = &array->declaration.p;
array->parent.declaration->id = CTF_TYPE_ARRAY;
- bt_
ctf_field_type_
get(element_type);
+ bt_get(element_type);
array->element_type = element_type;
array->length = length;
array->element_type = element_type;
array->length = length;
- bt_ctf_field_type_init(&array->parent);
+ bt_ctf_field_type_init(&array->parent
, FALSE
);
return &array->parent;
error:
return NULL;
return &array->parent;
error:
return NULL;
@@
-1546,7
+1540,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_array_get_element_type(
array = container_of(type, struct bt_ctf_field_type_array, parent);
ret = array->element_type;
array = container_of(type, struct bt_ctf_field_type_array, parent);
ret = array->element_type;
- bt_
ctf_field_type_
get(ret);
+ bt_get(ret);
end:
return ret;
}
end:
return ret;
}
@@
-1585,10
+1579,10
@@
struct bt_ctf_field_type *bt_ctf_field_type_sequence_create(
sequence->parent.declaration = &sequence->declaration.p;
sequence->parent.declaration->id = CTF_TYPE_SEQUENCE;
sequence->parent.declaration = &sequence->declaration.p;
sequence->parent.declaration->id = CTF_TYPE_SEQUENCE;
- bt_
ctf_field_type_
get(element_type);
+ bt_get(element_type);
sequence->element_type = element_type;
sequence->length_field_name = g_string_new(length_field_name);
sequence->element_type = element_type;
sequence->length_field_name = g_string_new(length_field_name);
- bt_ctf_field_type_init(&sequence->parent);
+ bt_ctf_field_type_init(&sequence->parent
, FALSE
);
return &sequence->parent;
error:
return NULL;
return &sequence->parent;
error:
return NULL;
@@
-1607,7
+1601,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_sequence_get_element_type(
sequence = container_of(type, struct bt_ctf_field_type_sequence,
parent);
ret = sequence->element_type;
sequence = container_of(type, struct bt_ctf_field_type_sequence,
parent);
ret = sequence->element_type;
- bt_
ctf_field_type_
get(ret);
+ bt_get(ret);
end:
return ret;
}
end:
return ret;
}
@@
-1640,7
+1634,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_string_create(void)
string->parent.declaration = &string->declaration.p;
string->parent.declaration->id = CTF_TYPE_STRING;
string->parent.declaration = &string->declaration.p;
string->parent.declaration->id = CTF_TYPE_STRING;
- bt_ctf_field_type_init(&string->parent);
+ bt_ctf_field_type_init(&string->parent
, TRUE
);
string->declaration.encoding = CTF_STRING_UTF8;
string->parent.declaration->alignment = CHAR_BIT;
return &string->parent;
string->declaration.encoding = CTF_STRING_UTF8;
string->parent.declaration->alignment = CHAR_BIT;
return &string->parent;
@@
-1710,7
+1704,7
@@
int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type)
}
ret = bt_ctf_field_type_get_alignment(element);
}
ret = bt_ctf_field_type_get_alignment(element);
- bt_
ctf_field_type_
put(element);
+ bt_put(element);
break;
}
case CTF_TYPE_ARRAY:
break;
}
case CTF_TYPE_ARRAY:
@@
-1724,7
+1718,7
@@
int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type)
}
ret = bt_ctf_field_type_get_alignment(element);
}
ret = bt_ctf_field_type_get_alignment(element);
- bt_
ctf_field_type_
put(element);
+ bt_put(element);
break;
}
case CTF_TYPE_STRUCT:
break;
}
case CTF_TYPE_STRUCT:
@@
-1751,7
+1745,7
@@
int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type)
assert(field);
field_alignment = bt_ctf_field_type_get_alignment(
field);
assert(field);
field_alignment = bt_ctf_field_type_get_alignment(
field);
- bt_
ctf_field_type_
put(field);
+ bt_put(field);
if (field_alignment < 0) {
ret = field_alignment;
goto end;
if (field_alignment < 0) {
ret = field_alignment;
goto end;
@@
-1774,14
+1768,20
@@
end:
return ret;
}
return ret;
}
+static inline
+int is_power_of_two(unsigned int value)
+{
+ return ((value & (value - 1)) == 0) && value > 0;
+}
+
int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type,
unsigned int alignment)
{
int ret = 0;
enum ctf_type_id type_id;
int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type,
unsigned int alignment)
{
int ret = 0;
enum ctf_type_id type_id;
- /* Alignment must be
bit-aligned (1) or byte aligned
*/
- if (!type || type->frozen ||
(alignment != 1 && (alignment & 0x7)
)) {
+ /* Alignment must be
a power of two
*/
+ if (!type || type->frozen ||
!is_power_of_two(alignment
)) {
ret = -1;
goto end;
}
ret = -1;
goto end;
}
@@
-1798,8
+1798,8
@@
int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type,
goto end;
}
goto end;
}
- if (type_id == CTF_TYPE_
STRUCT || type_id == CTF_TYPE_VARIANT
||
- type_id == CTF_TYPE_
SEQUENCE || type_id == CTF_TYPE_
ARRAY) {
+ if (type_id == CTF_TYPE_
VARIANT || type_id == CTF_TYPE_SEQUENCE
||
+ type_id == CTF_TYPE_ARRAY) {
/* Setting an alignment on these types makes no sense */
ret = -1;
goto end;
/* Setting an alignment on these types makes no sense */
ret = -1;
goto end;
@@
-1908,20
+1908,12
@@
enum ctf_type_id bt_ctf_field_type_get_type_id(
void bt_ctf_field_type_get(struct bt_ctf_field_type *type)
{
void bt_ctf_field_type_get(struct bt_ctf_field_type *type)
{
- if (!type) {
- return;
- }
-
- bt_ctf_ref_get(&type->ref_count);
+ bt_get(type);
}
void bt_ctf_field_type_put(struct bt_ctf_field_type *type)
{
}
void bt_ctf_field_type_put(struct bt_ctf_field_type *type)
{
- if (!type) {
- return;
- }
-
- bt_ctf_ref_put(&type->ref_count, bt_ctf_field_type_destroy);
+ bt_put(type);
}
BT_HIDDEN
}
BT_HIDDEN
@@
-2135,7
+2127,7
@@
int bt_ctf_field_type_structure_set_field_index(struct bt_ctf_field_type *type,
int ret = 0;
struct bt_ctf_field_type_structure *structure;
int ret = 0;
struct bt_ctf_field_type_structure *structure;
- if (!type || !field ||
type->frozen ||
+ if (!type || !field ||
bt_ctf_field_type_get_type_id(type) != CTF_TYPE_STRUCT) {
ret = -1;
goto end;
bt_ctf_field_type_get_type_id(type) != CTF_TYPE_STRUCT) {
ret = -1;
goto end;
@@
-2148,8
+2140,8
@@
int bt_ctf_field_type_structure_set_field_index(struct bt_ctf_field_type *type,
goto end;
}
goto end;
}
- bt_
ctf_field_type_
get(field);
- bt_
ctf_field_type_
put(((struct structure_field *)
+ bt_get(field);
+ bt_put(((struct structure_field *)
g_ptr_array_index(structure->fields, index))->type);
((struct structure_field *) structure->fields->pdata[index])->type =
field;
g_ptr_array_index(structure->fields, index))->type);
((struct structure_field *) structure->fields->pdata[index])->type =
field;
@@
-2213,6
+2205,18
@@
end:
return ret;
}
return ret;
}
+BT_HIDDEN
+struct bt_ctf_field_path *bt_ctf_field_type_sequence_get_length_field_path(
+ struct bt_ctf_field_type *type)
+{
+ struct bt_ctf_field_type_sequence *sequence;
+
+ sequence = container_of(type, struct bt_ctf_field_type_sequence,
+ parent);
+
+ return sequence->length_field_path;
+}
+
BT_HIDDEN
int bt_ctf_field_type_variant_set_tag_field_path(struct bt_ctf_field_type *type,
struct bt_ctf_field_path *path)
BT_HIDDEN
int bt_ctf_field_type_variant_set_tag_field_path(struct bt_ctf_field_type *type,
struct bt_ctf_field_path *path)
@@
-2235,6
+2239,18
@@
end:
return ret;
}
return ret;
}
+BT_HIDDEN
+struct bt_ctf_field_path *bt_ctf_field_type_variant_get_tag_field_path(
+ struct bt_ctf_field_type *type)
+{
+ struct bt_ctf_field_type_variant *variant;
+
+ variant = container_of(type, struct bt_ctf_field_type_variant,
+ parent);
+
+ return variant->tag_path;
+}
+
BT_HIDDEN
int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type,
struct bt_ctf_field_type *tag)
BT_HIDDEN
int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type,
struct bt_ctf_field_type *tag)
@@
-2250,9
+2266,9
@@
int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type,
variant = container_of(type, struct bt_ctf_field_type_variant,
parent);
variant = container_of(type, struct bt_ctf_field_type_variant,
parent);
- bt_
ctf_field_type_
get(tag);
+ bt_get(tag);
if (variant->tag) {
if (variant->tag) {
- bt_
ctf_field_type_
put(&variant->tag->parent);
+ bt_put(&variant->tag->parent);
}
variant->tag = container_of(tag, struct bt_ctf_field_type_enumeration,
parent);
}
variant->tag = container_of(tag, struct bt_ctf_field_type_enumeration,
parent);
@@
-2267,7
+2283,7
@@
int bt_ctf_field_type_variant_set_field_index(struct bt_ctf_field_type *type,
int ret = 0;
struct bt_ctf_field_type_variant *variant;
int ret = 0;
struct bt_ctf_field_type_variant *variant;
- if (!type || !field ||
type->frozen ||
+ if (!type || !field ||
bt_ctf_field_type_get_type_id(type) != CTF_TYPE_VARIANT) {
ret = -1;
goto end;
bt_ctf_field_type_get_type_id(type) != CTF_TYPE_VARIANT) {
ret = -1;
goto end;
@@
-2280,8
+2296,8
@@
int bt_ctf_field_type_variant_set_field_index(struct bt_ctf_field_type *type,
goto end;
}
goto end;
}
- bt_
ctf_field_type_
get(field);
- bt_
ctf_field_type_
put(((struct structure_field *)
+ bt_get(field);
+ bt_put(((struct structure_field *)
g_ptr_array_index(variant->fields, index))->type);
((struct structure_field *) variant->fields->pdata[index])->type =
field;
g_ptr_array_index(variant->fields, index))->type);
((struct structure_field *) variant->fields->pdata[index])->type =
field;
@@
-2290,138
+2306,120
@@
end:
}
static
}
static
-void bt_ctf_field_type_integer_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_integer_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_integer *integer;
+ struct bt_ctf_field_type_integer *integer =
+ (struct bt_ctf_field_type_integer *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- integer = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_integer, parent);
- if (integer->mapped_clock) {
- bt_ctf_clock_put(integer->mapped_clock);
- }
+ bt_put(integer->mapped_clock);
g_free(integer);
}
static
g_free(integer);
}
static
-void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_enumeration *enumeration;
+ struct bt_ctf_field_type_enumeration *enumeration =
+ (struct bt_ctf_field_type_enumeration *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- enumeration = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_enumeration, parent);
g_ptr_array_free(enumeration->entries, TRUE);
g_ptr_array_free(enumeration->entries, TRUE);
- bt_
ctf_field_type_
put(enumeration->container);
+ bt_put(enumeration->container);
g_free(enumeration);
}
static
g_free(enumeration);
}
static
-void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_floating_point *floating_point;
+ struct bt_ctf_field_type_floating_point *floating_point =
+ (struct bt_ctf_field_type_floating_point *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- floating_point = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_floating_point, parent);
g_free(floating_point);
}
static
g_free(floating_point);
}
static
-void bt_ctf_field_type_structure_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_structure_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_structure *structure;
+ struct bt_ctf_field_type_structure *structure =
+ (struct bt_ctf_field_type_structure *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- structure = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_structure, parent);
g_ptr_array_free(structure->fields, TRUE);
g_hash_table_destroy(structure->field_name_to_index);
g_free(structure);
}
static
g_ptr_array_free(structure->fields, TRUE);
g_hash_table_destroy(structure->field_name_to_index);
g_free(structure);
}
static
-void bt_ctf_field_type_variant_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_variant_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_variant *variant;
+ struct bt_ctf_field_type_variant *variant =
+ (struct bt_ctf_field_type_variant *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- variant = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_variant, parent);
g_ptr_array_free(variant->fields, TRUE);
g_hash_table_destroy(variant->field_name_to_index);
g_string_free(variant->tag_name, TRUE);
g_ptr_array_free(variant->fields, TRUE);
g_hash_table_destroy(variant->field_name_to_index);
g_string_free(variant->tag_name, TRUE);
- bt_
ctf_field_type_
put(&variant->tag->parent);
+ bt_put(&variant->tag->parent);
bt_ctf_field_path_destroy(variant->tag_path);
g_free(variant);
}
static
bt_ctf_field_path_destroy(variant->tag_path);
g_free(variant);
}
static
-void bt_ctf_field_type_array_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_array_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_array *array;
+ struct bt_ctf_field_type_array *array =
+ (struct bt_ctf_field_type_array *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- array = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_array, parent);
- bt_ctf_field_type_put(array->element_type);
+ bt_put(array->element_type);
g_free(array);
}
static
g_free(array);
}
static
-void bt_ctf_field_type_sequence_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_sequence_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_sequence *sequence;
+ struct bt_ctf_field_type_sequence *sequence =
+ (struct bt_ctf_field_type_sequence *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- sequence = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_sequence, parent);
- bt_ctf_field_type_put(sequence->element_type);
+ bt_put(sequence->element_type);
g_string_free(sequence->length_field_name, TRUE);
bt_ctf_field_path_destroy(sequence->length_field_path);
g_free(sequence);
}
static
g_string_free(sequence->length_field_name, TRUE);
bt_ctf_field_path_destroy(sequence->length_field_path);
g_free(sequence);
}
static
-void bt_ctf_field_type_string_destroy(struct bt_ctf_
ref *ref
)
+void bt_ctf_field_type_string_destroy(struct bt_ctf_
field_type *type
)
{
{
- struct bt_ctf_field_type_string *string;
+ struct bt_ctf_field_type_string *string =
+ (struct bt_ctf_field_type_string *) type;
- if (!
ref
) {
+ if (!
type
) {
return;
}
return;
}
- string = container_of(
- container_of(ref, struct bt_ctf_field_type, ref_count),
- struct bt_ctf_field_type_string, parent);
g_free(string);
}
g_free(string);
}
@@
-2659,7
+2657,7
@@
int bt_ctf_field_type_enumeration_serialize(struct bt_ctf_field_type *type,
g_string_assign(context->field_name, "");
}
error_put_container_type:
g_string_assign(context->field_name, "");
}
error_put_container_type:
- bt_
ctf_field_type_
put(container_type);
+ bt_put(container_type);
end:
return ret;
}
end:
return ret;
}
@@
-3001,7
+2999,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_integer_copy(
parent);
copy_integer->declaration = integer->declaration;
if (integer->mapped_clock) {
parent);
copy_integer->declaration = integer->declaration;
if (integer->mapped_clock) {
- bt_
ctf_clock_
get(integer->mapped_clock);
+ bt_get(integer->mapped_clock);
copy_integer->mapped_clock = integer->mapped_clock;
}
end:
copy_integer->mapped_clock = integer->mapped_clock;
}
end:
@@
-3049,16
+3047,12
@@
struct bt_ctf_field_type *bt_ctf_field_type_enumeration_copy(
copy_enumeration->declaration = enumeration->declaration;
end:
copy_enumeration->declaration = enumeration->declaration;
end:
- if (copy_container) {
- bt_ctf_field_type_put(copy_container);
- }
+ bt_put(copy_container);
return copy;
error:
return copy;
error:
- if (copy_container) {
- bt_ctf_field_type_put(copy_container);
- }
- bt_ctf_field_type_put(copy);
- return NULL;
+ bt_put(copy_container);
+ BT_PUT(copy);
+ return copy;
}
static
}
static
@@
-3137,8
+3131,8
@@
struct bt_ctf_field_type *bt_ctf_field_type_structure_copy(
end:
return copy;
error:
end:
return copy;
error:
-
bt_ctf_field_type_put
(copy);
- return
NULL
;
+
BT_PUT
(copy);
+ return
copy
;
}
static
}
static
@@
-3206,18
+3200,12
@@
struct bt_ctf_field_type *bt_ctf_field_type_variant_copy(
}
}
end:
}
}
end:
- if (copy_tag) {
- bt_ctf_field_type_put(copy_tag);
- }
-
+ bt_put(copy_tag);
return copy;
error:
return copy;
error:
- if (copy_tag) {
- bt_ctf_field_type_put(copy_tag);
- }
-
- bt_ctf_field_type_put(copy);
- return NULL;
+ bt_put(copy_tag);
+ BT_PUT(copy);
+ return copy;
}
static
}
static
@@
-3243,10
+3231,7
@@
struct bt_ctf_field_type *bt_ctf_field_type_array_copy(
parent);
copy_array->declaration = array->declaration;
end:
parent);
copy_array->declaration = array->declaration;
end:
- if (copy_element) {
- bt_ctf_field_type_put(copy_element);
- }
-
+ bt_put(copy_element);
return copy;
}
return copy;
}
@@
-3282,16
+3267,10
@@
struct bt_ctf_field_type *bt_ctf_field_type_sequence_copy(
}
}
end:
}
}
end:
- if (copy_element) {
- bt_ctf_field_type_put(copy_element);
- }
-
+ bt_put(copy_element);
return copy;
error:
return copy;
error:
- if (copy) {
- bt_ctf_field_type_put(copy);
- copy = NULL;
- }
+ BT_PUT(copy);
goto end;
}
goto end;
}
This page took
0.034161 seconds
and
4
git commands to generate.