int opt_clock_force_correlate;
static
-struct declaration *ctf_type_specifier_list_visit(FILE *fd,
+struct bt_declaration *ctf_type_specifier_list_visit(FILE *fd,
int depth, struct ctf_node *type_specifier_list,
struct declaration_scope *declaration_scope,
struct ctf_trace *trace);
}
static
-struct declaration *ctf_type_declarator_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_type_declarator_visit(FILE *fd, int depth,
struct ctf_node *type_specifier_list,
GQuark *field_name,
struct ctf_node *node_type_declarator,
struct declaration_scope *declaration_scope,
- struct declaration *nested_declaration,
+ struct bt_declaration *nested_declaration,
struct ctf_trace *trace)
{
/*
*/
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;
* 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);
*field_name = 0;
return nested_declaration;
} else {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
struct ctf_node *first;
/* TYPEDEC_NESTED */
GQuark field_name;
bt_list_for_each_entry(iter, type_declarators, siblings) {
- struct declaration *field_declaration;
+ struct bt_declaration *field_declaration;
field_declaration = ctf_type_declarator_visit(fd, depth,
type_specifier_list,
GQuark field_name;
bt_list_for_each_entry(iter, type_declarators, siblings) {
- struct declaration *field_declaration;
+ struct bt_declaration *field_declaration;
field_declaration = ctf_type_declarator_visit(fd, depth,
type_specifier_list,
return -EINVAL;
}
- 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;
}
- 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);
GQuark identifier;
bt_list_for_each_entry(iter, type_declarators, siblings) {
- struct declaration *type_declaration;
+ struct bt_declaration *type_declaration;
int ret;
type_declaration = ctf_type_declarator_visit(fd, depth,
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;
struct ctf_node *target, struct ctf_node *alias,
struct ctf_trace *trace)
{
- struct declaration *type_declaration;
+ struct bt_declaration *type_declaration;
struct ctf_node *node;
GQuark dummy_id;
GQuark alias_q;
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);
switch (iter->type) {
case NODE_TYPEDEF:
- /* For each declarator, declare type and add type to struct declaration scope */
+ /* For each declarator, declare type and add type to struct bt_declaration scope */
ret = ctf_typedef_visit(fd, depth,
struct_declaration->scope,
iter->u._typedef.type_specifier_list,
return ret;
break;
case NODE_TYPEALIAS:
- /* Declare type with declarator and add type to struct declaration scope */
+ /* Declare type with declarator and add type to struct bt_declaration scope */
ret = ctf_typealias_visit(fd, depth,
struct_declaration->scope,
iter->u.typealias.target,
}
static
-struct declaration *ctf_declaration_struct_visit(FILE *fd,
+struct bt_declaration *ctf_declaration_struct_visit(FILE *fd,
int depth, const char *name, struct bt_list_head *declaration_list,
int has_body, struct bt_list_head *min_align,
struct declaration_scope *declaration_scope,
}
static
-struct declaration *ctf_declaration_variant_visit(FILE *fd,
+struct bt_declaration *ctf_declaration_variant_visit(FILE *fd,
int depth, const char *name, const char *choice,
struct bt_list_head *declaration_list,
int has_body, struct declaration_scope *declaration_scope,
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) {
- 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;
}
}
- 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;
if (name) {
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);
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);
}
static
-struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
const char *name,
struct ctf_node *container_type,
struct bt_list_head *enumerator_list,
struct declaration_scope *declaration_scope,
struct ctf_trace *trace)
{
- struct declaration *declaration;
+ struct bt_declaration *declaration;
struct declaration_enum *enum_declaration;
struct declaration_integer *integer_declaration;
struct last_enum_value last_value;
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;
/* 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);
}
}
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__);
if (name) {
int ret;
- 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);
}
static
-struct declaration *ctf_declaration_type_specifier_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_declaration_type_specifier_visit(FILE *fd, int depth,
struct ctf_node *type_specifier_list,
struct declaration_scope *declaration_scope)
{
GString *str;
- struct declaration *declaration;
+ struct bt_declaration *declaration;
char *str_c;
int ret;
GQuark id_q;
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;
}
}
static
-struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
struct bt_list_head *expressions,
struct ctf_trace *trace)
{
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;
}
static
-struct declaration *ctf_declaration_floating_point_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_declaration_floating_point_visit(FILE *fd, int depth,
struct bt_list_head *expressions,
struct ctf_trace *trace)
{
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;
}
static
-struct declaration *ctf_declaration_string_visit(FILE *fd, int depth,
+struct bt_declaration *ctf_declaration_string_visit(FILE *fd, int depth,
struct bt_list_head *expressions,
struct ctf_trace *trace)
{
static
-struct declaration *ctf_type_specifier_list_visit(FILE *fd,
+struct bt_declaration *ctf_type_specifier_list_visit(FILE *fd,
int depth, struct ctf_node *type_specifier_list,
struct declaration_scope *declaration_scope,
struct ctf_trace *trace)
}
CTF_EVENT_SET_FIELD(event, stream_id);
} else if (!strcmp(left, "context")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (event->context_decl) {
fprintf(fd, "[error] %s: context already declared in event declaration\n", __func__);
}
event->context_decl = container_of(declaration, struct declaration_struct, p);
} else if (!strcmp(left, "fields")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (event->fields_decl) {
fprintf(fd, "[error] %s: fields already declared in event declaration\n", __func__);
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);
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;
}
}
CTF_STREAM_SET_FIELD(stream, stream_id);
} else if (!strcmp(left, "event.header")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (stream->event_header_decl) {
fprintf(fd, "[error] %s: event.header already declared in stream declaration\n", __func__);
}
stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
} else if (!strcmp(left, "event.context")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (stream->event_context_decl) {
fprintf(fd, "[error] %s: event.context already declared in stream declaration\n", __func__);
}
stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
} else if (!strcmp(left, "packet.context")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (stream->packet_context_decl) {
fprintf(fd, "[error] %s: packet.context already declared in stream declaration\n", __func__);
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();
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;
}
}
CTF_TRACE_SET_FIELD(trace, byte_order);
} else if (!strcmp(left, "packet.header")) {
- struct declaration *declaration;
+ struct bt_declaration *declaration;
if (trace->packet_header_decl) {
fprintf(fd, "[error] %s: packet.header already declared in trace declaration\n", __func__);
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) {
}
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;
}
if (opt_clock_force_correlate) {
/*
* User requested to forcibly correlate the clock
- * sources, even if we have no correlatation
+ * sources, even if we have no correlation
* information.
*/
if (!clock->absolute) {
break;
case NODE_TYPE_SPECIFIER_LIST:
{
- struct declaration *declaration;
+ struct bt_declaration *declaration;
/*
* Just add the type specifier to the root scope
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:
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
return ret;
error:
- 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_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);
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);
}
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);
projects / babeltrace.git / blobdiff