size_t len;
len = first->u.unary_expression.u.unsigned_constant;
- array_declaration = array_declaration_new(len, nested_declaration,
+ array_declaration = bt_array_declaration_new(len, nested_declaration,
declaration_scope);
if (!array_declaration) {
fprintf(fd, "[error] %s: cannot create array declaration.\n", __func__);
return NULL;
}
- declaration_unref(nested_declaration);
+ bt_declaration_unref(nested_declaration);
declaration = &array_declaration->p;
break;
}
char *length_name = concatenate_unary_strings(&node_type_declarator->u.type_declarator.u.nested.length);
struct declaration_sequence *sequence_declaration;
- sequence_declaration = sequence_declaration_new(length_name, nested_declaration, declaration_scope);
+ sequence_declaration = bt_sequence_declaration_new(length_name, nested_declaration, declaration_scope);
if (!sequence_declaration) {
fprintf(fd, "[error] %s: cannot create sequence declaration.\n", __func__);
g_free(length_name);
return NULL;
}
- declaration_unref(nested_declaration);
+ bt_declaration_unref(nested_declaration);
declaration = &sequence_declaration->p;
g_free(length_name);
break;
}
/* Check if field with same name already exists */
- if (struct_declaration_lookup_field_index(struct_declaration, field_name) >= 0) {
+ if (bt_struct_declaration_lookup_field_index(struct_declaration, field_name) >= 0) {
fprintf(fd, "[error] %s: duplicate field %s in struct\n", __func__, g_quark_to_string(field_name));
return -EINVAL;
}
- struct_declaration_add_field(struct_declaration,
+ bt_struct_declaration_add_field(struct_declaration,
g_quark_to_string(field_name),
field_declaration);
- declaration_unref(field_declaration);
+ bt_declaration_unref(field_declaration);
}
return 0;
}
untagged_variant_declaration_add_field(untagged_variant_declaration,
g_quark_to_string(field_name),
field_declaration);
- declaration_unref(field_declaration);
+ bt_declaration_unref(field_declaration);
}
return 0;
}
*/
if (type_declaration->id == CTF_TYPE_UNTAGGED_VARIANT) {
fprintf(fd, "[error] %s: typedef of untagged variant is not permitted.\n", __func__);
- declaration_unref(type_declaration);
+ bt_declaration_unref(type_declaration);
return -EPERM;
}
ret = register_declaration(identifier, type_declaration, scope);
type_declaration->declaration_free(type_declaration);
return ret;
}
- declaration_unref(type_declaration);
+ bt_declaration_unref(type_declaration);
}
return 0;
}
*/
if (type_declaration->id == CTF_TYPE_UNTAGGED_VARIANT) {
fprintf(fd, "[error] %s: typedef of untagged variant is not permitted.\n", __func__);
- declaration_unref(type_declaration);
+ bt_declaration_unref(type_declaration);
return -EPERM;
}
/*
err = register_declaration(alias_q, type_declaration, scope);
if (err)
goto error;
- declaration_unref(type_declaration);
+ bt_declaration_unref(type_declaration);
return 0;
error:
if (!has_body) {
assert(name);
struct_declaration =
- lookup_struct_declaration(g_quark_from_string(name),
+ bt_lookup_struct_declaration(g_quark_from_string(name),
declaration_scope);
- declaration_ref(&struct_declaration->p);
+ bt_declaration_ref(&struct_declaration->p);
return &struct_declaration->p;
} else {
uint64_t min_align_value = 0;
/* For unnamed struct, create type */
/* For named struct (with body), create type and add to declaration scope */
if (name) {
- if (lookup_struct_declaration(g_quark_from_string(name),
+ if (bt_lookup_struct_declaration(g_quark_from_string(name),
declaration_scope)) {
fprintf(fd, "[error] %s: struct %s already declared in scope\n", __func__, name);
goto error;
}
}
- struct_declaration = struct_declaration_new(declaration_scope,
+ struct_declaration = bt_struct_declaration_new(declaration_scope,
min_align_value);
bt_list_for_each_entry(iter, declaration_list, siblings) {
int ret;
if (name) {
int ret;
- ret = register_struct_declaration(g_quark_from_string(name),
+ ret = bt_register_struct_declaration(g_quark_from_string(name),
struct_declaration,
declaration_scope);
assert(!ret);
untagged_variant_declaration =
lookup_variant_declaration(g_quark_from_string(name),
declaration_scope);
- declaration_ref(&untagged_variant_declaration->p);
+ bt_declaration_ref(&untagged_variant_declaration->p);
} else {
/* For unnamed variant, create type */
/* For named variant (with body), create type and add to declaration scope */
variant_declaration = variant_declaration_new(untagged_variant_declaration, choice);
if (!variant_declaration)
goto error;
- declaration_unref(&untagged_variant_declaration->p);
+ bt_declaration_unref(&untagged_variant_declaration->p);
return &variant_declaration->p;
}
error:
if (nr_vals <= 1)
end = start;
last->u.s = end + 1;
- enum_signed_insert(enum_declaration, start, end, q);
+ bt_enum_signed_insert(enum_declaration, start, end, q);
} else {
uint64_t start, end;
int nr_vals = 0;
if (nr_vals <= 1)
end = start;
last->u.u = end + 1;
- enum_unsigned_insert(enum_declaration, start, end, q);
+ bt_enum_unsigned_insert(enum_declaration, start, end, q);
}
return 0;
}
enum_declaration =
lookup_enum_declaration(g_quark_from_string(name),
declaration_scope);
- declaration_ref(&enum_declaration->p);
+ bt_declaration_ref(&enum_declaration->p);
return &enum_declaration->p;
} else {
/* For unnamed enum, create type */
return NULL;
}
integer_declaration = container_of(declaration, struct declaration_integer, p);
- enum_declaration = enum_declaration_new(integer_declaration);
- declaration_unref(&integer_declaration->p); /* leave ref to enum */
+ enum_declaration = bt_enum_declaration_new(integer_declaration);
+ bt_declaration_unref(&integer_declaration->p); /* leave ref to enum */
if (enum_declaration->integer_declaration->signedness) {
last_value.u.s = 0;
} else {
enum_declaration,
declaration_scope);
assert(!ret);
- declaration_unref(&enum_declaration->p);
+ bt_declaration_unref(&enum_declaration->p);
}
return &enum_declaration->p;
}
id_q = g_quark_from_string(str_c);
g_free(str_c);
declaration = lookup_declaration(id_q, declaration_scope);
- declaration_ref(declaration);
+ bt_declaration_ref(declaration);
return declaration;
}
}
if (encoding_c && !strcmp(encoding_c, "ASCII"))
encoding = CTF_STRING_ASCII;
- string_declaration = string_declaration_new(encoding);
+ string_declaration = bt_string_declaration_new(encoding);
return &string_declaration->p;
}
error:
if (event->fields_decl)
- declaration_unref(&event->fields_decl->p);
+ bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
- declaration_unref(&event->context_decl->p);
+ bt_declaration_unref(&event->context_decl->p);
free_declaration_scope(event->declaration_scope);
g_free(event_decl);
return ret;
if (CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {
/* check that packet header has stream_id field. */
if (!trace->packet_header_decl
- || struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("stream_id")) < 0) {
+ || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("stream_id")) < 0) {
ret = -EPERM;
fprintf(fd, "[error] %s: missing stream_id field in packet header declaration, but stream_id attribute is declared for stream.\n", __func__);
goto error;
error:
if (stream->event_header_decl)
- declaration_unref(&stream->event_header_decl->p);
+ bt_declaration_unref(&stream->event_header_decl->p);
if (stream->event_context_decl)
- declaration_unref(&stream->event_context_decl->p);
+ bt_declaration_unref(&stream->event_context_decl->p);
if (stream->packet_context_decl)
- declaration_unref(&stream->packet_context_decl->p);
+ bt_declaration_unref(&stream->packet_context_decl->p);
g_ptr_array_free(stream->streams, TRUE);
g_ptr_array_free(stream->events_by_id, TRUE);
g_hash_table_destroy(stream->event_quark_to_id);
if (!CTF_TRACE_FIELD_IS_SET(trace, byte_order)) {
/* check that the packet header contains a "magic" field */
if (!trace->packet_header_decl
- || struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("magic")) < 0) {
+ || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("magic")) < 0) {
ret = -EPERM;
fprintf(fd, "[error] %s: missing both byte_order and packet header magic number in trace declaration\n", __func__);
goto error;
error:
if (trace->packet_header_decl) {
- declaration_unref(&trace->packet_header_decl->p);
+ bt_declaration_unref(&trace->packet_header_decl->p);
trace->packet_header_decl = NULL;
}
g_ptr_array_free(trace->streams, TRUE);
node, trace->root_declaration_scope, trace);
if (!declaration)
return -ENOMEM;
- declaration_unref(declaration);
+ bt_declaration_unref(declaration);
break;
}
default:
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);
}
if (stream->event_header_decl)
- declaration_unref(&stream->event_header_decl->p);
+ bt_declaration_unref(&stream->event_header_decl->p);
if (stream->event_context_decl)
- declaration_unref(&stream->event_context_decl->p);
+ bt_declaration_unref(&stream->event_context_decl->p);
if (stream->packet_context_decl)
- declaration_unref(&stream->packet_context_decl->p);
+ bt_declaration_unref(&stream->packet_context_decl->p);
g_ptr_array_free(stream->streams, TRUE);
g_ptr_array_free(stream->events_by_id, TRUE);
g_hash_table_destroy(stream->event_quark_to_id);
event = &event_decl->parent;
if (event->fields_decl)
- declaration_unref(&event->fields_decl->p);
+ bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
- declaration_unref(&event->context_decl->p);
+ bt_declaration_unref(&event->context_decl->p);
free_declaration_scope(event->declaration_scope);
g_free(event);
g_ptr_array_free(trace->event_declarations, TRUE);
}
if (trace->packet_header_decl)
- declaration_unref(&trace->packet_header_decl->p);
+ bt_declaration_unref(&trace->packet_header_decl->p);
free_declaration_scope(trace->root_declaration_scope);
free_declaration_scope(trace->declaration_scope);