Signed-off-by: Julien Desfossez <jdesfossez@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
if (!ctf_event || !scope || !field)
return NULL;
if (!ctf_event || !scope || !field)
return NULL;
- def = lookup_definition(scope, field);
+ def = bt_lookup_definition(scope, field);
/*
* optionally a field can have an underscore prefix, try
* to lookup the field with this prefix if it failed
/*
* optionally a field can have an underscore prefix, try
* to lookup the field with this prefix if it failed
field_underscore = g_new(char, strlen(field) + 2);
field_underscore[0] = '_';
strcpy(&field_underscore[1], field);
field_underscore = g_new(char, strlen(field) + 2);
field_underscore[0] = '_';
strcpy(&field_underscore[1], field);
- def = lookup_definition(scope, field_underscore);
+ def = bt_lookup_definition(scope, field_underscore);
g_free(field_underscore);
}
if (bt_ctf_field_type(bt_ctf_get_decl_from_def(def)) == CTF_TYPE_VARIANT) {
g_free(field_underscore);
}
if (bt_ctf_field_type(bt_ctf_get_decl_from_def(def)) == CTF_TYPE_VARIANT) {
* definition scopes.
*/
struct definition *
* definition scopes.
*/
struct definition *
- lookup_path_definition(GArray *cur_path, /* array of GQuark */
+ bt_lookup_path_definition(GArray *cur_path, /* array of GQuark */
GArray *lookup_path, /* array of GQuark */
struct definition_scope *scope);
GArray *lookup_path, /* array of GQuark */
struct definition_scope *scope);
-int register_field_definition(GQuark field_name,
+int bt_register_field_definition(GQuark field_name,
struct definition *definition,
struct definition_scope *scope);
struct definition_scope *
struct definition *definition,
struct definition_scope *scope);
struct definition_scope *
- new_definition_scope(struct definition_scope *parent_scope,
+ bt_new_definition_scope(struct definition_scope *parent_scope,
GQuark field_name, const char *root_name);
GQuark field_name, const char *root_name);
-void free_definition_scope(struct definition_scope *scope);
+void bt_free_definition_scope(struct definition_scope *scope);
-GQuark new_definition_path(struct definition_scope *parent_scope,
+GQuark bt_new_definition_path(struct definition_scope *parent_scope,
GQuark field_name, const char *root_name);
static inline
GQuark field_name, const char *root_name);
static inline
-struct definition *lookup_definition(const struct definition *definition,
+struct definition *bt_lookup_definition(const struct definition *definition,
const char *field_name);
struct definition_integer *lookup_integer(const struct definition *definition,
const char *field_name,
const char *field_name);
struct definition_integer *lookup_integer(const struct definition *definition,
const char *field_name,
*/
array->p.index = root_name ? INT_MAX : index;
array->p.name = field_name;
*/
array->p.index = root_name ? INT_MAX : index;
array->p.name = field_name;
- array->p.path = new_definition_path(parent_scope, field_name, root_name);
- array->p.scope = new_definition_scope(parent_scope, field_name, root_name);
- ret = register_field_definition(field_name, &array->p,
+ array->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
+ array->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
+ ret = bt_register_field_definition(field_name, &array->p,
parent_scope);
assert(!ret);
array->string = NULL;
parent_scope);
assert(!ret);
array->string = NULL;
field->declaration->definition_free(field);
}
(void) g_ptr_array_free(array->elems, TRUE);
field->declaration->definition_free(field);
}
(void) g_ptr_array_free(array->elems, TRUE);
- free_definition_scope(array->p.scope);
+ bt_free_definition_scope(array->p.scope);
bt_declaration_unref(array->p.declaration);
g_free(array);
return NULL;
bt_declaration_unref(array->p.declaration);
g_free(array);
return NULL;
}
(void) g_ptr_array_free(array->elems, TRUE);
}
}
(void) g_ptr_array_free(array->elems, TRUE);
}
- free_definition_scope(array->p.scope);
+ bt_free_definition_scope(array->p.scope);
bt_declaration_unref(array->p.declaration);
g_free(array);
}
bt_declaration_unref(array->p.declaration);
g_free(array);
}
*/
_enum->p.index = root_name ? INT_MAX : index;
_enum->p.name = field_name;
*/
_enum->p.index = root_name ? INT_MAX : index;
_enum->p.name = field_name;
- _enum->p.path = new_definition_path(parent_scope, field_name, root_name);
- _enum->p.scope = new_definition_scope(parent_scope, field_name, root_name);
+ _enum->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
+ _enum->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
- ret = register_field_definition(field_name, &_enum->p,
+ ret = bt_register_field_definition(field_name, &_enum->p,
parent_scope);
assert(!ret);
definition_integer_parent =
parent_scope);
assert(!ret);
definition_integer_parent =
container_of(definition, struct definition_enum, p);
bt_definition_unref(&_enum->integer->p);
container_of(definition, struct definition_enum, p);
bt_definition_unref(&_enum->integer->p);
- free_definition_scope(_enum->p.scope);
+ bt_free_definition_scope(_enum->p.scope);
bt_declaration_unref(_enum->p.declaration);
if (_enum->value)
g_array_unref(_enum->value);
bt_declaration_unref(_enum->p.declaration);
if (_enum->value)
g_array_unref(_enum->value);
bt_declaration_ref(&float_declaration->p);
_float->p.declaration = declaration;
_float->declaration = float_declaration;
bt_declaration_ref(&float_declaration->p);
_float->p.declaration = declaration;
_float->declaration = float_declaration;
- _float->p.scope = new_definition_scope(parent_scope, field_name, root_name);
- _float->p.path = new_definition_path(parent_scope, field_name, root_name);
+ _float->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
+ _float->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
if (float_declaration->byte_order == LITTLE_ENDIAN) {
tmp = float_declaration->mantissa->p.definition_new(&float_declaration->mantissa->p,
_float->p.scope, g_quark_from_static_string("mantissa"), 0, NULL);
if (float_declaration->byte_order == LITTLE_ENDIAN) {
tmp = float_declaration->mantissa->p.definition_new(&float_declaration->mantissa->p,
_float->p.scope, g_quark_from_static_string("mantissa"), 0, NULL);
if (parent_scope) {
int ret;
if (parent_scope) {
int ret;
- ret = register_field_definition(field_name, &_float->p,
+ ret = bt_register_field_definition(field_name, &_float->p,
parent_scope);
assert(!ret);
}
parent_scope);
assert(!ret);
}
bt_definition_unref(&_float->sign->p);
bt_definition_unref(&_float->exp->p);
bt_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_free_definition_scope(_float->p.scope);
bt_declaration_unref(_float->p.declaration);
g_free(_float);
}
bt_declaration_unref(_float->p.declaration);
g_free(_float);
}
*/
integer->p.index = root_name ? INT_MAX : index;
integer->p.name = field_name;
*/
integer->p.index = root_name ? INT_MAX : index;
integer->p.name = field_name;
- integer->p.path = new_definition_path(parent_scope, field_name,
+ integer->p.path = bt_new_definition_path(parent_scope, field_name,
root_name);
integer->p.scope = NULL;
integer->value._unsigned = 0;
root_name);
integer->p.scope = NULL;
integer->value._unsigned = 0;
- ret = register_field_definition(field_name, &integer->p,
+ ret = bt_register_field_definition(field_name, &integer->p,
parent_scope);
assert(!ret);
return &integer->p;
parent_scope);
assert(!ret);
return &integer->p;
*/
sequence->p.index = root_name ? INT_MAX : index;
sequence->p.name = field_name;
*/
sequence->p.index = root_name ? INT_MAX : index;
sequence->p.name = field_name;
- sequence->p.path = new_definition_path(parent_scope, field_name, root_name);
- sequence->p.scope = new_definition_scope(parent_scope, field_name, root_name);
- ret = register_field_definition(field_name, &sequence->p,
+ sequence->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
+ sequence->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
+ ret = bt_register_field_definition(field_name, &sequence->p,
parent_scope);
assert(!ret);
parent_scope);
assert(!ret);
- len_parent = lookup_path_definition(sequence->p.scope->scope_path,
+ len_parent = bt_lookup_path_definition(sequence->p.scope->scope_path,
sequence_declaration->length_name,
parent_scope);
if (!len_parent) {
sequence_declaration->length_name,
parent_scope);
if (!len_parent) {
return &sequence->p;
error:
return &sequence->p;
error:
- free_definition_scope(sequence->p.scope);
+ bt_free_definition_scope(sequence->p.scope);
bt_declaration_unref(&sequence_declaration->p);
g_free(sequence);
return NULL;
bt_declaration_unref(&sequence_declaration->p);
g_free(sequence);
return NULL;
(void) g_ptr_array_free(sequence->elems, TRUE);
}
bt_definition_unref(len_definition);
(void) g_ptr_array_free(sequence->elems, TRUE);
}
bt_definition_unref(len_definition);
- free_definition_scope(sequence->p.scope);
+ bt_free_definition_scope(sequence->p.scope);
bt_declaration_unref(sequence->p.declaration);
g_free(sequence);
}
bt_declaration_unref(sequence->p.declaration);
g_free(sequence);
}
*/
string->p.index = root_name ? INT_MAX : index;
string->p.name = field_name;
*/
string->p.index = root_name ? INT_MAX : index;
string->p.name = field_name;
- string->p.path = new_definition_path(parent_scope, field_name,
+ string->p.path = bt_new_definition_path(parent_scope, field_name,
root_name);
string->p.scope = NULL;
string->value = NULL;
string->len = 0;
string->alloc_len = 0;
root_name);
string->p.scope = NULL;
string->value = NULL;
string->len = 0;
string->alloc_len = 0;
- ret = register_field_definition(field_name, &string->p,
+ ret = bt_register_field_definition(field_name, &string->p,
parent_scope);
assert(!ret);
return &string->p;
parent_scope);
assert(!ret);
return &string->p;
*/
_struct->p.index = root_name ? INT_MAX : index;
_struct->p.name = field_name;
*/
_struct->p.index = root_name ? INT_MAX : index;
_struct->p.name = field_name;
- _struct->p.path = new_definition_path(parent_scope, field_name, root_name);
- _struct->p.scope = new_definition_scope(parent_scope, field_name, root_name);
+ _struct->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
+ _struct->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
- ret = register_field_definition(field_name, &_struct->p,
+ ret = bt_register_field_definition(field_name, &_struct->p,
parent_scope);
assert(!ret || ret == -EPERM);
parent_scope);
assert(!ret || ret == -EPERM);
struct definition *field = g_ptr_array_index(_struct->fields, i);
bt_definition_unref(field);
}
struct definition *field = g_ptr_array_index(_struct->fields, i);
bt_definition_unref(field);
}
- free_definition_scope(_struct->p.scope);
+ bt_free_definition_scope(_struct->p.scope);
bt_declaration_unref(&struct_declaration->p);
g_free(_struct);
return NULL;
bt_declaration_unref(&struct_declaration->p);
g_free(_struct);
return NULL;
struct definition *field = g_ptr_array_index(_struct->fields, i);
bt_definition_unref(field);
}
struct definition *field = g_ptr_array_index(_struct->fields, i);
bt_definition_unref(field);
}
- free_definition_scope(_struct->p.scope);
+ bt_free_definition_scope(_struct->p.scope);
bt_declaration_unref(_struct->p.declaration);
g_ptr_array_free(_struct->fields, TRUE);
g_free(_struct);
bt_declaration_unref(_struct->p.declaration);
g_ptr_array_free(_struct->fields, TRUE);
g_free(_struct);
* scope: the definition scope containing the variant definition.
*/
struct definition *
* scope: the definition scope containing the variant definition.
*/
struct definition *
- lookup_path_definition(GArray *cur_path,
+ bt_lookup_path_definition(GArray *cur_path,
GArray *lookup_path,
struct definition_scope *scope)
{
GArray *lookup_path,
struct definition_scope *scope)
{
-int register_field_definition(GQuark field_name, struct definition *definition,
+int bt_register_field_definition(GQuark field_name, struct definition *definition,
struct definition_scope *scope)
{
if (!scope || !field_name)
struct definition_scope *scope)
{
if (!scope || !field_name)
}
static struct definition_scope *
}
static struct definition_scope *
- _new_definition_scope(struct definition_scope *parent_scope,
+ _bt_new_definition_scope(struct definition_scope *parent_scope,
int scope_path_len)
{
struct definition_scope *scope = g_new(struct definition_scope, 1);
int scope_path_len)
{
struct definition_scope *scope = g_new(struct definition_scope, 1);
-GQuark new_definition_path(struct definition_scope *parent_scope,
+GQuark bt_new_definition_path(struct definition_scope *parent_scope,
GQuark field_name, const char *root_name)
{
GQuark path;
GQuark field_name, const char *root_name)
{
GQuark path;
}
struct definition_scope *
}
struct definition_scope *
- new_definition_scope(struct definition_scope *parent_scope,
+ bt_new_definition_scope(struct definition_scope *parent_scope,
GQuark field_name, const char *root_name)
{
struct definition_scope *scope;
if (root_name) {
GQuark field_name, const char *root_name)
{
struct definition_scope *scope;
if (root_name) {
- scope = _new_definition_scope(parent_scope, 0);
+ scope = _bt_new_definition_scope(parent_scope, 0);
bt_append_scope_path(root_name, scope->scope_path);
} else {
int scope_path_len = 1;
assert(parent_scope);
scope_path_len += parent_scope->scope_path->len;
bt_append_scope_path(root_name, scope->scope_path);
} else {
int scope_path_len = 1;
assert(parent_scope);
scope_path_len += parent_scope->scope_path->len;
- scope = _new_definition_scope(parent_scope, scope_path_len);
+ scope = _bt_new_definition_scope(parent_scope, scope_path_len);
memcpy(scope->scope_path->data, parent_scope->scope_path->data,
sizeof(GQuark) * (scope_path_len - 1));
g_array_index(scope->scope_path, GQuark, scope_path_len - 1) =
memcpy(scope->scope_path->data, parent_scope->scope_path->data,
sizeof(GQuark) * (scope_path_len - 1));
g_array_index(scope->scope_path, GQuark, scope_path_len - 1) =
-void free_definition_scope(struct definition_scope *scope)
+void bt_free_definition_scope(struct definition_scope *scope)
{
g_array_free(scope->scope_path, TRUE);
g_hash_table_destroy(scope->definitions);
g_free(scope);
}
{
g_array_free(scope->scope_path, TRUE);
g_hash_table_destroy(scope->definitions);
g_free(scope);
}
-struct definition *lookup_definition(const struct definition *definition,
+struct definition *bt_lookup_definition(const struct definition *definition,
const char *field_name)
{
struct definition_scope *scope = get_definition_scope(definition);
const char *field_name)
{
struct definition_scope *scope = get_definition_scope(definition);
struct definition *lookup;
struct definition_integer *lookup_integer;
struct definition *lookup;
struct definition_integer *lookup_integer;
- lookup = lookup_definition(definition, field_name);
+ lookup = bt_lookup_definition(definition, field_name);
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_INTEGER)
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_INTEGER)
struct definition *lookup;
struct definition_enum *lookup_enum;
struct definition *lookup;
struct definition_enum *lookup_enum;
- lookup = lookup_definition(definition, field_name);
+ lookup = bt_lookup_definition(definition, field_name);
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_ENUM)
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_ENUM)
struct definition *lookup;
struct definition_variant *bt_lookup_variant;
struct definition *lookup;
struct definition_variant *bt_lookup_variant;
- lookup = lookup_definition(definition, field_name);
+ lookup = bt_lookup_definition(definition, field_name);
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_VARIANT)
if (!lookup)
return NULL;
if (lookup->declaration->id != CTF_TYPE_VARIANT)
*/
variant->p.index = root_name ? INT_MAX : index;
variant->p.name = field_name;
*/
variant->p.index = root_name ? INT_MAX : index;
variant->p.name = field_name;
- variant->p.path = new_definition_path(parent_scope, field_name, root_name);
- variant->p.scope = new_definition_scope(parent_scope, field_name, root_name);
+ variant->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
+ variant->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
- ret = register_field_definition(field_name, &variant->p,
+ ret = bt_register_field_definition(field_name, &variant->p,
parent_scope);
assert(!ret);
parent_scope);
assert(!ret);
- variant->enum_tag = lookup_path_definition(variant->p.scope->scope_path,
+ variant->enum_tag = bt_lookup_path_definition(variant->p.scope->scope_path,
variant_declaration->tag_name,
parent_scope);
variant_declaration->tag_name,
parent_scope);
variant->current_field = NULL;
return &variant->p;
error:
variant->current_field = NULL;
return &variant->p;
error:
- free_definition_scope(variant->p.scope);
+ bt_free_definition_scope(variant->p.scope);
bt_declaration_unref(&variant_declaration->p);
g_free(variant);
return NULL;
bt_declaration_unref(&variant_declaration->p);
g_free(variant);
return NULL;
bt_definition_unref(field);
}
bt_definition_unref(variant->enum_tag);
bt_definition_unref(field);
}
bt_definition_unref(variant->enum_tag);
- free_definition_scope(variant->p.scope);
+ bt_free_definition_scope(variant->p.scope);
bt_declaration_unref(variant->p.declaration);
g_ptr_array_free(variant->fields, TRUE);
g_free(variant);
bt_declaration_unref(variant->p.declaration);
g_ptr_array_free(variant->fields, TRUE);
g_free(variant);