Signed-off-by: Julien Desfossez <jdesfossez@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*/
alias_q = create_typealias_identifier(fd, depth,
type_specifier_list, node_type_declarator);
*/
alias_q = create_typealias_identifier(fd, depth,
type_specifier_list, node_type_declarator);
- nested_declaration = lookup_declaration(alias_q, declaration_scope);
+ nested_declaration = bt_lookup_declaration(alias_q, declaration_scope);
if (!nested_declaration) {
fprintf(fd, "[error] %s: cannot find typealias \"%s\".\n", __func__, g_quark_to_string(alias_q));
return NULL;
if (!nested_declaration) {
fprintf(fd, "[error] %s: cannot find typealias \"%s\".\n", __func__, g_quark_to_string(alias_q));
return NULL;
* integer declaration to modify it. There could be other references to
* it.
*/
* integer declaration to modify it. There could be other references to
* it.
*/
- integer_declaration = integer_declaration_new(integer_declaration->len,
+ integer_declaration = bt_integer_declaration_new(integer_declaration->len,
integer_declaration->byte_order, integer_declaration->signedness,
integer_declaration->p.alignment, 16, integer_declaration->encoding,
integer_declaration->clock);
integer_declaration->byte_order, integer_declaration->signedness,
integer_declaration->p.alignment, 16, integer_declaration->encoding,
integer_declaration->clock);
- if (untagged_variant_declaration_get_field_from_tag(untagged_variant_declaration, field_name) != NULL) {
+ if (bt_untagged_variant_declaration_get_field_from_tag(untagged_variant_declaration, field_name) != NULL) {
fprintf(fd, "[error] %s: duplicate field %s in variant\n", __func__, g_quark_to_string(field_name));
return -EINVAL;
}
fprintf(fd, "[error] %s: duplicate field %s in variant\n", __func__, g_quark_to_string(field_name));
return -EINVAL;
}
- untagged_variant_declaration_add_field(untagged_variant_declaration,
+ bt_untagged_variant_declaration_add_field(untagged_variant_declaration,
g_quark_to_string(field_name),
field_declaration);
bt_declaration_unref(field_declaration);
g_quark_to_string(field_name),
field_declaration);
bt_declaration_unref(field_declaration);
bt_declaration_unref(type_declaration);
return -EPERM;
}
bt_declaration_unref(type_declaration);
return -EPERM;
}
- ret = register_declaration(identifier, type_declaration, scope);
+ ret = bt_register_declaration(identifier, type_declaration, scope);
if (ret) {
type_declaration->declaration_free(type_declaration);
return ret;
if (ret) {
type_declaration->declaration_free(type_declaration);
return ret;
struct ctf_node, siblings);
alias_q = create_typealias_identifier(fd, depth,
alias->u.typealias_alias.type_specifier_list, node);
struct ctf_node, siblings);
alias_q = create_typealias_identifier(fd, depth,
alias->u.typealias_alias.type_specifier_list, node);
- err = register_declaration(alias_q, type_declaration, scope);
+ err = bt_register_declaration(alias_q, type_declaration, scope);
if (err)
goto error;
bt_declaration_unref(type_declaration);
if (err)
goto error;
bt_declaration_unref(type_declaration);
if (!has_body) {
assert(name);
untagged_variant_declaration =
if (!has_body) {
assert(name);
untagged_variant_declaration =
- lookup_variant_declaration(g_quark_from_string(name),
+ bt_lookup_variant_declaration(g_quark_from_string(name),
declaration_scope);
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 */
if (name) {
declaration_scope);
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 */
if (name) {
- if (lookup_variant_declaration(g_quark_from_string(name),
+ if (bt_lookup_variant_declaration(g_quark_from_string(name),
declaration_scope)) {
fprintf(fd, "[error] %s: variant %s already declared in scope\n", __func__, name);
return NULL;
}
}
declaration_scope)) {
fprintf(fd, "[error] %s: variant %s already declared in scope\n", __func__, name);
return NULL;
}
}
- untagged_variant_declaration = untagged_variant_declaration_new(declaration_scope);
+ untagged_variant_declaration = bt_untagged_bt_variant_declaration_new(declaration_scope);
bt_list_for_each_entry(iter, declaration_list, siblings) {
int ret;
bt_list_for_each_entry(iter, declaration_list, siblings) {
int ret;
- ret = register_variant_declaration(g_quark_from_string(name),
+ ret = bt_register_variant_declaration(g_quark_from_string(name),
untagged_variant_declaration,
declaration_scope);
assert(!ret);
untagged_variant_declaration,
declaration_scope);
assert(!ret);
if (!choice) {
return &untagged_variant_declaration->p;
} else {
if (!choice) {
return &untagged_variant_declaration->p;
} else {
- variant_declaration = variant_declaration_new(untagged_variant_declaration, choice);
+ variant_declaration = bt_variant_declaration_new(untagged_variant_declaration, choice);
if (!variant_declaration)
goto error;
bt_declaration_unref(&untagged_variant_declaration->p);
if (!variant_declaration)
goto error;
bt_declaration_unref(&untagged_variant_declaration->p);
if (!has_body) {
assert(name);
enum_declaration =
if (!has_body) {
assert(name);
enum_declaration =
- lookup_enum_declaration(g_quark_from_string(name),
+ bt_lookup_enum_declaration(g_quark_from_string(name),
declaration_scope);
bt_declaration_ref(&enum_declaration->p);
return &enum_declaration->p;
declaration_scope);
bt_declaration_ref(&enum_declaration->p);
return &enum_declaration->p;
/* For unnamed enum, create type */
/* For named enum (with body), create type and add to declaration scope */
if (name) {
/* For unnamed enum, create type */
/* For named enum (with body), create type and add to declaration scope */
if (name) {
- if (lookup_enum_declaration(g_quark_from_string(name),
+ if (bt_lookup_enum_declaration(g_quark_from_string(name),
declaration_scope)) {
fprintf(fd, "[error] %s: enum %s already declared in scope\n", __func__, name);
declaration_scope)) {
fprintf(fd, "[error] %s: enum %s already declared in scope\n", __func__, name);
}
}
if (!container_type) {
}
}
if (!container_type) {
- declaration = lookup_declaration(g_quark_from_static_string("int"),
+ declaration = bt_lookup_declaration(g_quark_from_static_string("int"),
declaration_scope);
if (!declaration) {
fprintf(fd, "[error] %s: \"int\" type declaration missing for enumeration\n", __func__);
declaration_scope);
if (!declaration) {
fprintf(fd, "[error] %s: \"int\" type declaration missing for enumeration\n", __func__);
- ret = register_enum_declaration(g_quark_from_string(name),
+ ret = bt_register_enum_declaration(g_quark_from_string(name),
enum_declaration,
declaration_scope);
assert(!ret);
enum_declaration,
declaration_scope);
assert(!ret);
str_c = g_string_free(str, FALSE);
id_q = g_quark_from_string(str_c);
g_free(str_c);
str_c = g_string_free(str, FALSE);
id_q = g_quark_from_string(str_c);
g_free(str_c);
- declaration = lookup_declaration(id_q, declaration_scope);
+ declaration = bt_lookup_declaration(id_q, declaration_scope);
bt_declaration_ref(declaration);
return declaration;
}
bt_declaration_ref(declaration);
return declaration;
}
alignment = CHAR_BIT;
}
}
alignment = CHAR_BIT;
}
}
- integer_declaration = integer_declaration_new(size,
+ integer_declaration = bt_integer_declaration_new(size,
byte_order, signedness, alignment,
base, encoding, clock);
return &integer_declaration->p;
byte_order, signedness, alignment,
base, encoding, clock);
return &integer_declaration->p;
alignment = CHAR_BIT;
}
}
alignment = CHAR_BIT;
}
}
- float_declaration = float_declaration_new(mant_dig, exp_dig,
+ float_declaration = bt_float_declaration_new(mant_dig, exp_dig,
byte_order, alignment);
return &float_declaration->p;
}
byte_order, alignment);
return &float_declaration->p;
}
event_decl = g_new0(struct bt_ctf_event_decl, 1);
event = &event_decl->parent;
event_decl = g_new0(struct bt_ctf_event_decl, 1);
event = &event_decl->parent;
- event->declaration_scope = new_declaration_scope(parent_declaration_scope);
+ event->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
event->loglevel = -1;
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
event->loglevel = -1;
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
bt_declaration_unref(&event->context_decl->p);
bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
bt_declaration_unref(&event->context_decl->p);
- free_declaration_scope(event->declaration_scope);
+ bt_free_declaration_scope(event->declaration_scope);
g_free(event_decl);
return ret;
}
g_free(event_decl);
return ret;
}
struct ctf_stream_declaration *stream;
stream = g_new0(struct ctf_stream_declaration, 1);
struct ctf_stream_declaration *stream;
stream = g_new0(struct ctf_stream_declaration, 1);
- stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
+ stream->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
stream->events_by_id = g_ptr_array_new();
stream->event_quark_to_id = g_hash_table_new(g_direct_hash, g_direct_equal);
stream->streams = g_ptr_array_new();
stream->events_by_id = g_ptr_array_new();
stream->event_quark_to_id = g_hash_table_new(g_direct_hash, g_direct_equal);
stream->streams = g_ptr_array_new();
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);
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);
- free_declaration_scope(stream->declaration_scope);
+ bt_free_declaration_scope(stream->declaration_scope);
g_free(stream);
return ret;
}
g_free(stream);
return ret;
}
if (trace->declaration_scope)
return -EEXIST;
if (trace->declaration_scope)
return -EEXIST;
- trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
+ trace->declaration_scope = bt_new_declaration_scope(trace->root_declaration_scope);
trace->streams = g_ptr_array_new();
trace->event_declarations = g_ptr_array_new();
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
trace->streams = g_ptr_array_new();
trace->event_declarations = g_ptr_array_new();
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
}
g_ptr_array_free(trace->streams, TRUE);
g_ptr_array_free(trace->event_declarations, TRUE);
}
g_ptr_array_free(trace->streams, TRUE);
g_ptr_array_free(trace->event_declarations, TRUE);
- free_declaration_scope(trace->declaration_scope);
+ bt_free_declaration_scope(trace->declaration_scope);
trace->declaration_scope = NULL;
return ret;
}
trace->declaration_scope = NULL;
return ret;
}
NULL, callsite_free);
retry:
NULL, callsite_free);
retry:
- trace->root_declaration_scope = new_declaration_scope(NULL);
+ trace->root_declaration_scope = bt_new_declaration_scope(NULL);
switch (node->type) {
case NODE_ROOT:
switch (node->type) {
case NODE_ROOT:
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = ctf_trace_visit(fd, depth + 1, iter, trace);
if (ret == -EINTR) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = ctf_trace_visit(fd, depth + 1, iter, trace);
if (ret == -EINTR) {
- free_declaration_scope(trace->root_declaration_scope);
+ bt_free_declaration_scope(trace->root_declaration_scope);
/*
* Need to restart creation of type
* definitions, aliases and
/*
* Need to restart creation of type
* definitions, aliases and
- free_declaration_scope(trace->root_declaration_scope);
+ bt_free_declaration_scope(trace->root_declaration_scope);
g_hash_table_destroy(trace->callsites);
g_hash_table_destroy(trace->clocks);
return ret;
g_hash_table_destroy(trace->callsites);
g_hash_table_destroy(trace->clocks);
return ret;
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);
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);
- free_declaration_scope(stream->declaration_scope);
+ bt_free_declaration_scope(stream->declaration_scope);
g_free(stream);
}
g_ptr_array_free(trace->streams, TRUE);
g_free(stream);
}
g_ptr_array_free(trace->streams, TRUE);
bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
bt_declaration_unref(&event->context_decl->p);
bt_declaration_unref(&event->fields_decl->p);
if (event->context_decl)
bt_declaration_unref(&event->context_decl->p);
- free_declaration_scope(event->declaration_scope);
+ bt_free_declaration_scope(event->declaration_scope);
if (trace->packet_header_decl)
bt_declaration_unref(&trace->packet_header_decl->p);
if (trace->packet_header_decl)
bt_declaration_unref(&trace->packet_header_decl->p);
- free_declaration_scope(trace->root_declaration_scope);
- free_declaration_scope(trace->declaration_scope);
+ bt_free_declaration_scope(trace->root_declaration_scope);
+ bt_free_declaration_scope(trace->declaration_scope);
g_hash_table_destroy(trace->callsites);
g_hash_table_destroy(trace->clocks);
g_hash_table_destroy(trace->callsites);
g_hash_table_destroy(trace->clocks);
void __attribute__((constructor)) ctf_float_init(void)
{
static_float_declaration =
void __attribute__((constructor)) ctf_float_init(void)
{
static_float_declaration =
- float_declaration_new(FLT_MANT_DIG,
+ bt_float_declaration_new(FLT_MANT_DIG,
sizeof(float) * CHAR_BIT - FLT_MANT_DIG,
BYTE_ORDER,
__alignof__(float));
static_double_declaration =
sizeof(float) * CHAR_BIT - FLT_MANT_DIG,
BYTE_ORDER,
__alignof__(float));
static_double_declaration =
- float_declaration_new(DBL_MANT_DIG,
+ bt_float_declaration_new(DBL_MANT_DIG,
sizeof(double) * CHAR_BIT - DBL_MANT_DIG,
BYTE_ORDER,
__alignof__(double));
sizeof(double) * CHAR_BIT - DBL_MANT_DIG,
BYTE_ORDER,
__alignof__(double));
GString *string; /* String for encoded integer children */
};
GString *string; /* String for encoded integer children */
};
-int register_declaration(GQuark declaration_name,
+int bt_register_declaration(GQuark declaration_name,
struct declaration *declaration,
struct declaration_scope *scope);
struct declaration *declaration,
struct declaration_scope *scope);
-struct declaration *lookup_declaration(GQuark declaration_name,
+struct declaration *bt_lookup_declaration(GQuark declaration_name,
struct declaration_scope *scope);
/*
struct declaration_scope *scope);
/*
struct declaration_struct *
bt_lookup_struct_declaration(GQuark struct_name,
struct declaration_scope *scope);
struct declaration_struct *
bt_lookup_struct_declaration(GQuark struct_name,
struct declaration_scope *scope);
-int register_variant_declaration(GQuark variant_name,
+int bt_register_variant_declaration(GQuark variant_name,
struct declaration_untagged_variant *untagged_variant_declaration,
struct declaration_scope *scope);
struct declaration_untagged_variant *untagged_variant_declaration,
struct declaration_scope *scope);
-struct declaration_untagged_variant *lookup_variant_declaration(GQuark variant_name,
+struct declaration_untagged_variant *bt_lookup_variant_declaration(GQuark variant_name,
struct declaration_scope *scope);
struct declaration_scope *scope);
-int register_enum_declaration(GQuark enum_name,
+int bt_register_enum_declaration(GQuark enum_name,
struct declaration_enum *enum_declaration,
struct declaration_scope *scope);
struct declaration_enum *
struct declaration_enum *enum_declaration,
struct declaration_scope *scope);
struct declaration_enum *
- lookup_enum_declaration(GQuark enum_name,
+ bt_lookup_enum_declaration(GQuark enum_name,
struct declaration_scope *scope);
struct declaration_scope *
struct declaration_scope *scope);
struct declaration_scope *
- new_declaration_scope(struct declaration_scope *parent_scope);
-void free_declaration_scope(struct declaration_scope *scope);
+ bt_new_declaration_scope(struct declaration_scope *parent_scope);
+void bt_free_declaration_scope(struct declaration_scope *scope);
/*
* field_definition is for field definitions. They are registered into
/*
* field_definition is for field definitions. They are registered into
void bt_definition_ref(struct definition *definition);
void bt_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,
+struct declaration_integer *bt_integer_declaration_new(size_t len, int byte_order,
int signedness, size_t alignment,
int base, enum ctf_string_encoding encoding,
struct ctf_clock *clock);
int signedness, size_t alignment,
int base, enum ctf_string_encoding encoding,
struct ctf_clock *clock);
* mantissa_len is the length of the number of bytes represented by the mantissa
* (e.g. result of DBL_MANT_DIG). It includes the leading 1.
*/
* mantissa_len is the length of the number of bytes represented by the mantissa
* (e.g. result of DBL_MANT_DIG). It includes the leading 1.
*/
-struct declaration_float *float_declaration_new(size_t mantissa_len,
+struct declaration_float *bt_float_declaration_new(size_t mantissa_len,
size_t exp_len, int byte_order,
size_t alignment);
size_t exp_len, int byte_order,
size_t alignment);
* from numeric values to a single tag. Overlapping tag value ranges are
* therefore forbidden.
*/
* from numeric values to a single tag. Overlapping tag value ranges are
* therefore forbidden.
*/
-struct declaration_untagged_variant *untagged_variant_declaration_new(
+struct declaration_untagged_variant *bt_untagged_bt_variant_declaration_new(
struct declaration_scope *parent_scope);
struct declaration_scope *parent_scope);
-struct declaration_variant *variant_declaration_new(struct declaration_untagged_variant *untagged_variant,
+struct declaration_variant *bt_variant_declaration_new(struct declaration_untagged_variant *untagged_variant,
-void untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
+void bt_untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
const char *field_name,
struct declaration *field_declaration);
struct declaration_field *
const char *field_name,
struct declaration *field_declaration);
struct declaration_field *
- untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration,
+ bt_untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration,
GQuark tag);
/*
* Returns 0 on success, -EPERM on error.
GQuark tag);
/*
* Returns 0 on success, -EPERM on error.
struct declaration_array *array_declaration =
container_of(declaration, struct declaration_array, p);
struct declaration_array *array_declaration =
container_of(declaration, struct declaration_array, p);
- free_declaration_scope(array_declaration->scope);
+ bt_free_declaration_scope(array_declaration->scope);
bt_declaration_unref(array_declaration->elem);
g_free(array_declaration);
}
bt_declaration_unref(array_declaration->elem);
g_free(array_declaration);
}
array_declaration->len = len;
bt_declaration_ref(elem_declaration);
array_declaration->elem = elem_declaration;
array_declaration->len = len;
bt_declaration_ref(elem_declaration);
array_declaration->elem = elem_declaration;
- array_declaration->scope = new_declaration_scope(parent_scope);
+ array_declaration->scope = bt_new_declaration_scope(parent_scope);
declaration->id = CTF_TYPE_ARRAY;
declaration->alignment = elem_declaration->alignment;
declaration->declaration_free = _array_declaration_free;
declaration->id = CTF_TYPE_ARRAY;
declaration->alignment = elem_declaration->alignment;
declaration->declaration_free = _array_declaration_free;
}
struct declaration_float *
}
struct declaration_float *
- float_declaration_new(size_t mantissa_len,
+ bt_float_declaration_new(size_t mantissa_len,
size_t exp_len, int byte_order, size_t alignment)
{
struct declaration_float *float_declaration;
size_t exp_len, int byte_order, size_t alignment)
{
struct declaration_float *float_declaration;
declaration->ref = 1;
float_declaration->byte_order = byte_order;
declaration->ref = 1;
float_declaration->byte_order = byte_order;
- float_declaration->sign = integer_declaration_new(1,
+ float_declaration->sign = bt_integer_declaration_new(1,
byte_order, false, 1, 2,
CTF_STRING_NONE, NULL);
byte_order, false, 1, 2,
CTF_STRING_NONE, NULL);
- float_declaration->mantissa = integer_declaration_new(mantissa_len - 1,
+ float_declaration->mantissa = bt_integer_declaration_new(mantissa_len - 1,
byte_order, false, 1, 10,
CTF_STRING_NONE, NULL);
byte_order, false, 1, 10,
CTF_STRING_NONE, NULL);
- float_declaration->exp = integer_declaration_new(exp_len,
+ float_declaration->exp = bt_integer_declaration_new(exp_len,
byte_order, true, 1, 10,
CTF_STRING_NONE, NULL);
return float_declaration;
byte_order, true, 1, 10,
CTF_STRING_NONE, NULL);
return float_declaration;
}
struct declaration_integer *
}
struct declaration_integer *
- integer_declaration_new(size_t len, int byte_order,
+ bt_integer_declaration_new(size_t len, int byte_order,
int signedness, size_t alignment, int base,
enum ctf_string_encoding encoding,
struct ctf_clock *clock)
int signedness, size_t alignment, int base,
enum ctf_string_encoding encoding,
struct ctf_clock *clock)
struct declaration_sequence *sequence_declaration =
container_of(declaration, struct declaration_sequence, p);
struct declaration_sequence *sequence_declaration =
container_of(declaration, struct declaration_sequence, p);
- free_declaration_scope(sequence_declaration->scope);
+ bt_free_declaration_scope(sequence_declaration->scope);
g_array_free(sequence_declaration->length_name, TRUE);
bt_declaration_unref(sequence_declaration->elem);
g_free(sequence_declaration);
g_array_free(sequence_declaration->length_name, TRUE);
bt_declaration_unref(sequence_declaration->elem);
g_free(sequence_declaration);
bt_declaration_ref(elem_declaration);
sequence_declaration->elem = elem_declaration;
bt_declaration_ref(elem_declaration);
sequence_declaration->elem = elem_declaration;
- sequence_declaration->scope = new_declaration_scope(parent_scope);
+ sequence_declaration->scope = bt_new_declaration_scope(parent_scope);
declaration->id = CTF_TYPE_SEQUENCE;
declaration->alignment = elem_declaration->alignment;
declaration->declaration_free = _sequence_declaration_free;
declaration->id = CTF_TYPE_SEQUENCE;
declaration->alignment = elem_declaration->alignment;
declaration->declaration_free = _sequence_declaration_free;
container_of(declaration, struct declaration_struct, p);
unsigned long i;
container_of(declaration, struct declaration_struct, p);
unsigned long i;
- free_declaration_scope(struct_declaration->scope);
+ bt_free_declaration_scope(struct_declaration->scope);
g_hash_table_destroy(struct_declaration->fields_by_name);
for (i = 0; i < struct_declaration->fields->len; i++) {
g_hash_table_destroy(struct_declaration->fields_by_name);
for (i = 0; i < struct_declaration->fields->len; i++) {
struct_declaration->fields = g_array_sized_new(FALSE, TRUE,
sizeof(struct declaration_field),
DEFAULT_NR_STRUCT_FIELDS);
struct_declaration->fields = g_array_sized_new(FALSE, TRUE,
sizeof(struct declaration_field),
DEFAULT_NR_STRUCT_FIELDS);
- struct_declaration->scope = new_declaration_scope(parent_scope);
+ struct_declaration->scope = bt_new_declaration_scope(parent_scope);
declaration->id = CTF_TYPE_STRUCT;
declaration->alignment = max(1, min_align);
declaration->declaration_free = _struct_declaration_free;
declaration->id = CTF_TYPE_STRUCT;
declaration->alignment = max(1, min_align);
declaration->declaration_free = _struct_declaration_free;
static
struct declaration *
static
struct declaration *
- lookup_declaration_scope(GQuark declaration_name,
+ bt_lookup_declaration_scope(GQuark declaration_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->typedef_declarations,
(gconstpointer) (unsigned long) declaration_name);
}
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->typedef_declarations,
(gconstpointer) (unsigned long) declaration_name);
}
-struct declaration *lookup_declaration(GQuark declaration_name,
+struct declaration *bt_lookup_declaration(GQuark declaration_name,
struct declaration_scope *scope)
{
struct declaration *declaration;
while (scope) {
struct declaration_scope *scope)
{
struct declaration *declaration;
while (scope) {
- declaration = lookup_declaration_scope(declaration_name,
+ declaration = bt_lookup_declaration_scope(declaration_name,
scope);
if (declaration)
return declaration;
scope);
if (declaration)
return declaration;
-int register_declaration(GQuark name, struct declaration *declaration,
+int bt_register_declaration(GQuark name, struct declaration *declaration,
struct declaration_scope *scope)
{
if (!name)
return -EPERM;
/* Only lookup in local scope */
struct declaration_scope *scope)
{
if (!name)
return -EPERM;
/* Only lookup in local scope */
- if (lookup_declaration_scope(name, scope))
+ if (bt_lookup_declaration_scope(name, scope))
return -EEXIST;
g_hash_table_insert(scope->typedef_declarations,
return -EEXIST;
g_hash_table_insert(scope->typedef_declarations,
}
struct declaration_scope *
}
struct declaration_scope *
- new_declaration_scope(struct declaration_scope *parent_scope)
+ bt_new_declaration_scope(struct declaration_scope *parent_scope)
{
struct declaration_scope *scope = g_new(struct declaration_scope, 1);
{
struct declaration_scope *scope = g_new(struct declaration_scope, 1);
-void free_declaration_scope(struct declaration_scope *scope)
+void bt_free_declaration_scope(struct declaration_scope *scope)
{
g_hash_table_destroy(scope->enum_declarations);
g_hash_table_destroy(scope->variant_declarations);
{
g_hash_table_destroy(scope->enum_declarations);
g_hash_table_destroy(scope->variant_declarations);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("struct ", struct_name);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("struct ", struct_name);
- ret = register_declaration(prefix_name, &struct_declaration->p, scope);
+ ret = bt_register_declaration(prefix_name, &struct_declaration->p, scope);
assert(!ret);
return 0;
}
static
struct declaration_untagged_variant *
assert(!ret);
return 0;
}
static
struct declaration_untagged_variant *
- lookup_variant_declaration_scope(GQuark variant_name,
+ bt_lookup_variant_declaration_scope(GQuark variant_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->variant_declarations,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->variant_declarations,
}
struct declaration_untagged_variant *
}
struct declaration_untagged_variant *
- lookup_variant_declaration(GQuark variant_name,
+ bt_lookup_variant_declaration(GQuark variant_name,
struct declaration_scope *scope)
{
struct declaration_untagged_variant *declaration;
while (scope) {
struct declaration_scope *scope)
{
struct declaration_untagged_variant *declaration;
while (scope) {
- declaration = lookup_variant_declaration_scope(variant_name, scope);
+ declaration = bt_lookup_variant_declaration_scope(variant_name, scope);
if (declaration)
return declaration;
scope = scope->parent_scope;
if (declaration)
return declaration;
scope = scope->parent_scope;
-int register_variant_declaration(GQuark variant_name,
+int bt_register_variant_declaration(GQuark variant_name,
struct declaration_untagged_variant *untagged_variant_declaration,
struct declaration_scope *scope)
{
struct declaration_untagged_variant *untagged_variant_declaration,
struct declaration_scope *scope)
{
return -EPERM;
/* Only lookup in local scope */
return -EPERM;
/* Only lookup in local scope */
- if (lookup_variant_declaration_scope(variant_name, scope))
+ if (bt_lookup_variant_declaration_scope(variant_name, scope))
return -EEXIST;
g_hash_table_insert(scope->variant_declarations,
return -EEXIST;
g_hash_table_insert(scope->variant_declarations,
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("variant ", variant_name);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("variant ", variant_name);
- ret = register_declaration(prefix_name,
+ ret = bt_register_declaration(prefix_name,
&untagged_variant_declaration->p, scope);
assert(!ret);
return 0;
&untagged_variant_declaration->p, scope);
assert(!ret);
return 0;
static
struct declaration_enum *
static
struct declaration_enum *
- lookup_enum_declaration_scope(GQuark enum_name,
+ bt_lookup_enum_declaration_scope(GQuark enum_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->enum_declarations,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->enum_declarations,
}
struct declaration_enum *
}
struct declaration_enum *
- lookup_enum_declaration(GQuark enum_name,
+ bt_lookup_enum_declaration(GQuark enum_name,
struct declaration_scope *scope)
{
struct declaration_enum *declaration;
while (scope) {
struct declaration_scope *scope)
{
struct declaration_enum *declaration;
while (scope) {
- declaration = lookup_enum_declaration_scope(enum_name, scope);
+ declaration = bt_lookup_enum_declaration_scope(enum_name, scope);
if (declaration)
return declaration;
scope = scope->parent_scope;
if (declaration)
return declaration;
scope = scope->parent_scope;
-int register_enum_declaration(GQuark enum_name,
+int bt_register_enum_declaration(GQuark enum_name,
struct declaration_enum *enum_declaration,
struct declaration_scope *scope)
{
struct declaration_enum *enum_declaration,
struct declaration_scope *scope)
{
return -EPERM;
/* Only lookup in local scope */
return -EPERM;
/* Only lookup in local scope */
- if (lookup_enum_declaration_scope(enum_name, scope))
+ if (bt_lookup_enum_declaration_scope(enum_name, scope))
return -EEXIST;
g_hash_table_insert(scope->enum_declarations,
return -EEXIST;
g_hash_table_insert(scope->enum_declarations,
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("enum ", enum_name);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("enum ", enum_name);
- ret = register_declaration(prefix_name, &enum_declaration->p, scope);
+ ret = bt_register_declaration(prefix_name, &enum_declaration->p, scope);
assert(!ret);
return 0;
}
assert(!ret);
return 0;
}
container_of(declaration, struct declaration_untagged_variant, p);
unsigned long i;
container_of(declaration, struct declaration_untagged_variant, p);
unsigned long i;
- free_declaration_scope(untagged_variant_declaration->scope);
+ bt_free_declaration_scope(untagged_variant_declaration->scope);
g_hash_table_destroy(untagged_variant_declaration->fields_by_tag);
for (i = 0; i < untagged_variant_declaration->fields->len; i++) {
g_hash_table_destroy(untagged_variant_declaration->fields_by_tag);
for (i = 0; i < untagged_variant_declaration->fields->len; i++) {
g_free(untagged_variant_declaration);
}
g_free(untagged_variant_declaration);
}
-struct declaration_untagged_variant *untagged_variant_declaration_new(
+struct declaration_untagged_variant *bt_untagged_bt_variant_declaration_new(
struct declaration_scope *parent_scope)
{
struct declaration_untagged_variant *untagged_variant_declaration;
struct declaration_scope *parent_scope)
{
struct declaration_untagged_variant *untagged_variant_declaration;
untagged_variant_declaration->fields = g_array_sized_new(FALSE, TRUE,
sizeof(struct declaration_field),
DEFAULT_NR_STRUCT_FIELDS);
untagged_variant_declaration->fields = g_array_sized_new(FALSE, TRUE,
sizeof(struct declaration_field),
DEFAULT_NR_STRUCT_FIELDS);
- untagged_variant_declaration->scope = new_declaration_scope(parent_scope);
+ untagged_variant_declaration->scope = bt_new_declaration_scope(parent_scope);
declaration->id = CTF_TYPE_UNTAGGED_VARIANT;
declaration->alignment = 1;
declaration->declaration_free = _untagged_variant_declaration_free;
declaration->id = CTF_TYPE_UNTAGGED_VARIANT;
declaration->alignment = 1;
declaration->declaration_free = _untagged_variant_declaration_free;
}
struct declaration_variant *
}
struct declaration_variant *
- variant_declaration_new(struct declaration_untagged_variant *untagged_variant, const char *tag)
+ bt_variant_declaration_new(struct declaration_untagged_variant *untagged_variant, const char *tag)
{
struct declaration_variant *variant_declaration;
struct declaration *declaration;
{
struct declaration_variant *variant_declaration;
struct declaration *declaration;
-void untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
+void bt_untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
const char *field_name,
struct declaration *field_declaration)
{
const char *field_name,
struct declaration *field_declaration)
{
}
struct declaration_field *
}
struct declaration_field *
-untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration, GQuark tag)
+bt_untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration, GQuark tag)
{
gpointer index;
gboolean found;
{
gpointer index;
gboolean found;