error:
if (stream_event->event_fields)
- definition_unref(&stream_event->event_fields->p);
+ bt_definition_unref(&stream_event->event_fields->p);
if (stream_event->event_context)
- definition_unref(&stream_event->event_context->p);
+ bt_definition_unref(&stream_event->event_context->p);
return NULL;
}
g_ptr_array_free(stream->events_by_id, TRUE);
error:
if (stream->stream_event_context)
- definition_unref(&stream->stream_event_context->p);
+ bt_definition_unref(&stream->stream_event_context->p);
if (stream->stream_event_header)
- definition_unref(&stream->stream_event_header->p);
+ bt_definition_unref(&stream->stream_event_header->p);
if (stream->stream_packet_context)
- definition_unref(&stream->stream_packet_context->p);
+ bt_definition_unref(&stream->stream_packet_context->p);
return ret;
}
error_index:
if (file_stream->parent.trace_packet_header)
- definition_unref(&file_stream->parent.trace_packet_header->p);
+ bt_definition_unref(&file_stream->parent.trace_packet_header->p);
error_def:
closeret = ctf_fini_pos(&file_stream->pos);
if (closeret) {
error_index:
if (file_stream->parent.trace_packet_header)
- definition_unref(&file_stream->parent.trace_packet_header->p);
+ bt_definition_unref(&file_stream->parent.trace_packet_header->p);
error_def:
g_free(file_stream);
return ret;
if (!event)
continue;
if (&event->event_fields->p)
- definition_unref(&event->event_fields->p);
+ bt_definition_unref(&event->event_fields->p);
if (&event->event_context->p)
- definition_unref(&event->event_context->p);
+ bt_definition_unref(&event->event_context->p);
g_free(event);
}
if (&stream_def->trace_packet_header->p)
- definition_unref(&stream_def->trace_packet_header->p);
+ bt_definition_unref(&stream_def->trace_packet_header->p);
if (&stream_def->stream_event_header->p)
- definition_unref(&stream_def->stream_event_header->p);
+ bt_definition_unref(&stream_def->stream_event_header->p);
if (&stream_def->stream_packet_context->p)
- definition_unref(&stream_def->stream_packet_context->p);
+ bt_definition_unref(&stream_def->stream_packet_context->p);
if (&stream_def->stream_event_context->p)
- definition_unref(&stream_def->stream_event_context->p);
+ bt_definition_unref(&stream_def->stream_event_context->p);
g_ptr_array_free(stream_def->events_by_id, TRUE);
g_free(stream_def);
}
}
end_unref:
- definition_unref(tmpdef);
+ bt_definition_unref(tmpdef);
end:
float_unlock();
return ret;
ret = _ctf_float_copy(ppos, float_definition, &srcp.parent, tmpfloat);
end_unref:
- definition_unref(tmpdef);
+ bt_definition_unref(tmpdef);
end:
float_unlock();
return ret;
void bt_declaration_ref(struct declaration *declaration);
void bt_declaration_unref(struct declaration *declaration);
-void definition_ref(struct definition *definition);
-void definition_unref(struct definition *definition);
+void bt_definition_ref(struct definition *definition);
+void bt_definition_unref(struct definition *definition);
struct declaration_integer *integer_declaration_new(size_t len, int byte_order,
int signedness, size_t alignment,
struct definition_enum *_enum =
container_of(definition, struct definition_enum, p);
- definition_unref(&_enum->integer->p);
+ bt_definition_unref(&_enum->integer->p);
free_definition_scope(_enum->p.scope);
bt_declaration_unref(_enum->p.declaration);
if (_enum->value)
struct definition_float *_float =
container_of(definition, struct definition_float, p);
- definition_unref(&_float->sign->p);
- definition_unref(&_float->exp->p);
- definition_unref(&_float->mantissa->p);
+ bt_definition_unref(&_float->sign->p);
+ bt_definition_unref(&_float->exp->p);
+ bt_definition_unref(&_float->mantissa->p);
free_definition_scope(_float->p.scope);
bt_declaration_unref(_float->p.declaration);
g_free(_float);
printf("[error] Sequence length field should be unsigned.\n");
goto error;
}
- definition_ref(len_parent);
+ bt_definition_ref(len_parent);
sequence->string = NULL;
sequence->elems = NULL;
}
(void) g_ptr_array_free(sequence->elems, TRUE);
}
- definition_unref(len_definition);
+ bt_definition_unref(len_definition);
free_definition_scope(sequence->p.scope);
bt_declaration_unref(sequence->p.declaration);
g_free(sequence);
error:
for (i--; i >= 0; i--) {
struct definition *field = g_ptr_array_index(_struct->fields, i);
- definition_unref(field);
+ bt_definition_unref(field);
}
free_definition_scope(_struct->p.scope);
bt_declaration_unref(&struct_declaration->p);
assert(_struct->fields->len == _struct->declaration->fields->len);
for (i = 0; i < _struct->fields->len; i++) {
struct definition *field = g_ptr_array_index(_struct->fields, i);
- definition_unref(field);
+ bt_definition_unref(field);
}
free_definition_scope(_struct->p.scope);
bt_declaration_unref(_struct->p.declaration);
declaration->declaration_free(declaration);
}
-void definition_ref(struct definition *definition)
+void bt_definition_ref(struct definition *definition)
{
definition->ref++;
}
-void definition_unref(struct definition *definition)
+void bt_definition_unref(struct definition *definition)
{
if (!definition)
return;
if (!variant->enum_tag
|| check_enum_tag(variant, variant->enum_tag) < 0)
goto error;
- definition_ref(variant->enum_tag);
+ bt_definition_ref(variant->enum_tag);
variant->fields = g_ptr_array_sized_new(variant_declaration->untagged_variant->fields->len);
g_ptr_array_set_size(variant->fields, variant_declaration->untagged_variant->fields->len);
for (i = 0; i < variant_declaration->untagged_variant->fields->len; i++) {
assert(variant->fields->len == variant->declaration->untagged_variant->fields->len);
for (i = 0; i < variant->fields->len; i++) {
struct definition *field = g_ptr_array_index(variant->fields, i);
- definition_unref(field);
+ bt_definition_unref(field);
}
- definition_unref(variant->enum_tag);
+ bt_definition_unref(variant->enum_tag);
free_definition_scope(variant->p.scope);
bt_declaration_unref(variant->p.declaration);
g_ptr_array_free(variant->fields, TRUE);