#include <errno.h>
#include <babeltrace/compat/uuid-internal.h>
#include <babeltrace/endian-internal.h>
-#include <babeltrace/ref.h>
-#include <babeltrace/ctf-ir/trace.h>
-#include <babeltrace/ctf-ir/stream-class.h>
-#include <babeltrace/ctf-ir/event.h>
-#include <babeltrace/ctf-ir/event-class.h>
-#include <babeltrace/ctf-ir/field-types.h>
+#include <babeltrace/babeltrace.h>
#include <babeltrace/ctf-ir/field-types-internal.h>
-#include <babeltrace/ctf-ir/clock-class.h>
#include "scanner.h"
#include "parser.h"
#define _BT_LIST_FIRST_ENTRY(_ptr, _type, _member) \
bt_list_entry((_ptr)->next, _type, _member)
-#define _BT_CTF_FIELD_TYPE_INIT(_name) struct bt_ctf_field_type *_name = NULL;
+#define _BT_FIELD_TYPE_INIT(_name) struct bt_field_type *_name = NULL;
#define _BT_LOGE_DUP_ATTR(_node, _attr, _entity) \
_BT_LOGE_LINENO((_node)->lineno, \
/*
* Alias name to field type.
*
- * GQuark -> struct bt_ctf_field_type *
+ * GQuark -> struct bt_field_type *
*/
GHashTable *decl_map;
*/
struct ctx {
/* Trace being filled (owned by this) */
- struct bt_ctf_trace *trace;
+ struct bt_trace *trace;
/* Current declaration scope (top of the stack) */
struct ctx_decl_scope *current_scope;
char *trace_name_suffix;
/* Trace attributes */
- enum bt_ctf_byte_order trace_bo;
+ enum bt_byte_order trace_bo;
uint64_t trace_major;
uint64_t trace_minor;
unsigned char trace_uuid[BABELTRACE_UUID_LEN];
/*
* Stream IDs to stream classes.
*
- * int64_t -> struct bt_ctf_stream_class *
+ * int64_t -> struct bt_stream_class *
*/
GHashTable *stream_classes;
}
scope->decl_map = g_hash_table_new_full(g_direct_hash, g_direct_equal,
- NULL, (GDestroyNotify) bt_ctf_field_type_put);
+ NULL, (GDestroyNotify) bt_put);
scope->parent_scope = par_scope;
end:
* @returns Declaration, or NULL if not found
*/
static
-struct bt_ctf_field_type *ctx_decl_scope_lookup_prefix_alias(
+struct bt_field_type *ctx_decl_scope_lookup_prefix_alias(
struct ctx_decl_scope *scope, char prefix,
const char *name, int levels)
{
GQuark qname = 0;
int cur_levels = 0;
- _BT_CTF_FIELD_TYPE_INIT(decl);
+ _BT_FIELD_TYPE_INIT(decl);
struct ctx_decl_scope *cur_scope = scope;
assert(scope);
* @returns Declaration, or NULL if not found
*/
static
-struct bt_ctf_field_type *ctx_decl_scope_lookup_alias(
+struct bt_field_type *ctx_decl_scope_lookup_alias(
struct ctx_decl_scope *scope, const char *name, int levels)
{
return ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_ALIAS,
* @returns Declaration, or NULL if not found
*/
static
-struct bt_ctf_field_type *ctx_decl_scope_lookup_enum(
+struct bt_field_type *ctx_decl_scope_lookup_enum(
struct ctx_decl_scope *scope, const char *name, int levels)
{
return ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_ENUM,
* @returns Declaration, or NULL if not found
*/
static
-struct bt_ctf_field_type *ctx_decl_scope_lookup_struct(
+struct bt_field_type *ctx_decl_scope_lookup_struct(
struct ctx_decl_scope *scope, const char *name, int levels)
{
return ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_STRUCT,
* @returns Declaration, or NULL if not found
*/
static
-struct bt_ctf_field_type *ctx_decl_scope_lookup_variant(
+struct bt_field_type *ctx_decl_scope_lookup_variant(
struct ctx_decl_scope *scope, const char *name, int levels)
{
return ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_VARIANT,
*/
static
int ctx_decl_scope_register_prefix_alias(struct ctx_decl_scope *scope,
- char prefix, const char *name, struct bt_ctf_field_type *decl)
+ char prefix, const char *name, struct bt_field_type *decl)
{
int ret = 0;
GQuark qname = 0;
- _BT_CTF_FIELD_TYPE_INIT(edecl);
+ _BT_FIELD_TYPE_INIT(edecl);
assert(scope);
assert(name);
*/
static
int ctx_decl_scope_register_alias(struct ctx_decl_scope *scope,
- const char *name, struct bt_ctf_field_type *decl)
+ const char *name, struct bt_field_type *decl)
{
return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_ALIAS,
name, decl);
*/
static
int ctx_decl_scope_register_enum(struct ctx_decl_scope *scope,
- const char *name, struct bt_ctf_field_type *decl)
+ const char *name, struct bt_field_type *decl)
{
return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_ENUM,
name, decl);
*/
static
int ctx_decl_scope_register_struct(struct ctx_decl_scope *scope,
- const char *name, struct bt_ctf_field_type *decl)
+ const char *name, struct bt_field_type *decl)
{
return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_STRUCT,
name, decl);
*/
static
int ctx_decl_scope_register_variant(struct ctx_decl_scope *scope,
- const char *name, struct bt_ctf_field_type *decl)
+ const char *name, struct bt_field_type *decl)
{
return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_VARIANT,
name, decl);
* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(struct bt_ctf_trace *trace,
+struct ctx *ctx_create(struct bt_trace *trace,
const struct ctf_metadata_decoder_config *decoder_config,
const char *trace_name_suffix)
{
goto error;
}
- ctx->stream_classes = g_hash_table_new_full(g_direct_hash,
- g_direct_equal, NULL, (GDestroyNotify) bt_put);
+ ctx->stream_classes = g_hash_table_new_full(g_int64_hash,
+ g_int64_equal, g_free, (GDestroyNotify) bt_put);
if (!ctx->stream_classes) {
BT_LOGE_STR("Failed to allocate a GHashTable.");
goto error;
ctx->trace = trace;
ctx->current_scope = scope;
scope = NULL;
- ctx->trace_bo = BT_CTF_BYTE_ORDER_NATIVE;
+ ctx->trace_bo = BT_BYTE_ORDER_NATIVE;
ctx->decoder_config = *decoder_config;
return ctx;
static
int visit_type_specifier_list(struct ctx *ctx, struct ctf_node *ts_list,
- struct bt_ctf_field_type **decl);
+ struct bt_field_type **decl);
+
+static
+char *remove_underscores_from_field_ref(const char *field_ref)
+{
+ const char *in_ch;
+ char *out_ch;
+ char *ret;
+ enum {
+ UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE,
+ UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE,
+ } state = UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE;
+
+ assert(field_ref);
+ ret = calloc(strlen(field_ref) + 1, 1);
+ if (!ret) {
+ BT_LOGE("Failed to allocate a string: size=%zu",
+ strlen(field_ref) + 1);
+ goto end;
+ }
+
+ in_ch = field_ref;
+ out_ch = ret;
+
+ while (*in_ch != '\0') {
+ switch (*in_ch) {
+ case ' ':
+ case '\t':
+ /* Remove whitespace */
+ in_ch++;
+ continue;
+ case '_':
+ if (state == UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE) {
+ in_ch++;
+ state = UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE;
+ continue;
+ }
+
+ goto copy;
+ case '.':
+ state = UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE;
+ goto copy;
+ default:
+ state = UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE;
+ goto copy;
+ }
+
+copy:
+ *out_ch = *in_ch;
+ in_ch++;
+ out_ch++;
+ }
+
+end:
+ return ret;
+}
static
int is_unary_string(struct bt_list_head *head)
int uexpr_type = node->u.unary_expression.type;
int uexpr_link = node->u.unary_expression.link;
int cond = node->type != NODE_UNARY_EXPRESSION ||
- (uexpr_type != UNARY_UNSIGNED_CONSTANT) ||
(uexpr_type != UNARY_UNSIGNED_CONSTANT &&
uexpr_type != UNARY_SIGNED_CONSTANT) ||
uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
goto end;
}
- switch (node->u.unary_expression.type) {
+ switch (uexpr_type) {
case UNARY_UNSIGNED_CONSTANT:
*value = (int64_t)
node->u.unary_expression.u.unsigned_constant;
}
static
-enum bt_ctf_byte_order byte_order_from_unary_expr(struct ctf_node *unary_expr)
+enum bt_byte_order byte_order_from_unary_expr(struct ctf_node *unary_expr)
{
const char *str;
- enum bt_ctf_byte_order bo = BT_CTF_BYTE_ORDER_UNKNOWN;
+ enum bt_byte_order bo = BT_BYTE_ORDER_UNKNOWN;
if (unary_expr->u.unary_expression.type != UNARY_STRING) {
_BT_LOGE_NODE(unary_expr,
str = unary_expr->u.unary_expression.u.string;
if (!strcmp(str, "be") || !strcmp(str, "network")) {
- bo = BT_CTF_BYTE_ORDER_BIG_ENDIAN;
+ bo = BT_BYTE_ORDER_BIG_ENDIAN;
} else if (!strcmp(str, "le")) {
- bo = BT_CTF_BYTE_ORDER_LITTLE_ENDIAN;
+ bo = BT_BYTE_ORDER_LITTLE_ENDIAN;
} else if (!strcmp(str, "native")) {
- bo = BT_CTF_BYTE_ORDER_NATIVE;
+ bo = BT_BYTE_ORDER_NATIVE;
} else {
_BT_LOGE_NODE(unary_expr,
"Unexpected \"byte_order\" attribute value: "
}
static
-enum bt_ctf_byte_order get_real_byte_order(struct ctx *ctx,
+enum bt_byte_order get_real_byte_order(struct ctx *ctx,
struct ctf_node *uexpr)
{
- enum bt_ctf_byte_order bo = byte_order_from_unary_expr(uexpr);
+ enum bt_byte_order bo = byte_order_from_unary_expr(uexpr);
- if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
- bo = bt_ctf_trace_get_native_byte_order(ctx->trace);
+ if (bo == BT_BYTE_ORDER_NATIVE) {
+ bo = bt_trace_get_native_byte_order(ctx->trace);
}
return bo;
static
int is_align_valid(uint64_t align)
{
- return (align != 0) && !(align & (align - 1));
+ return (align != 0) && !(align & (align - 1ULL));
}
static
static
int visit_type_declarator(struct ctx *ctx, struct ctf_node *type_specifier_list,
GQuark *field_name, struct ctf_node *node_type_declarator,
- struct bt_ctf_field_type **field_decl,
- struct bt_ctf_field_type *nested_decl)
+ struct bt_field_type **field_decl,
+ struct bt_field_type *nested_decl)
{
/*
* During this whole function, nested_decl is always OURS,
if (node_type_declarator && !bt_list_empty(pointers)) {
GQuark qalias;
- _BT_CTF_FIELD_TYPE_INIT(nested_decl_copy);
+ _BT_FIELD_TYPE_INIT(nested_decl_copy);
/*
* If we have a pointer declarator, it HAS to
}
/* Make a copy of it */
- nested_decl_copy = bt_ctf_field_type_copy(nested_decl);
+ nested_decl_copy = bt_field_type_copy(nested_decl);
BT_PUT(nested_decl);
if (!nested_decl_copy) {
_BT_LOGE_NODE(node_type_declarator,
BT_MOVE(nested_decl, nested_decl_copy);
/* Force integer's base to 16 since it's a pointer */
- if (bt_ctf_field_type_is_integer(nested_decl)) {
- ret = bt_ctf_field_type_integer_set_base(
+ if (bt_field_type_is_integer(nested_decl)) {
+ ret = bt_field_type_integer_set_base(
nested_decl,
- BT_CTF_INTEGER_BASE_HEXADECIMAL);
+ BT_INTEGER_BASE_HEXADECIMAL);
assert(ret == 0);
}
} else {
const char *id =
node_type_declarator->u.type_declarator.u.id;
+ if (id[0] == '_') {
+ id++;
+ }
+
*field_name = g_quark_from_string(id);
} else {
*field_name = 0;
goto end;
} else {
struct ctf_node *first;
- _BT_CTF_FIELD_TYPE_INIT(decl);
- _BT_CTF_FIELD_TYPE_INIT(outer_field_decl);
+ _BT_FIELD_TYPE_INIT(decl);
+ _BT_FIELD_TYPE_INIT(outer_field_decl);
struct bt_list_head *length =
&node_type_declarator->
u.type_declarator.u.nested.length;
case UNARY_UNSIGNED_CONSTANT:
{
size_t len;
- _BT_CTF_FIELD_TYPE_INIT(array_decl);
+ _BT_FIELD_TYPE_INIT(array_decl);
len = first->u.unary_expression.u.unsigned_constant;
- array_decl = bt_ctf_field_type_array_create(nested_decl,
+ array_decl = bt_field_type_array_create(nested_decl,
len);
BT_PUT(nested_decl);
if (!array_decl) {
case UNARY_STRING:
{
/* Lookup unsigned integer definition, create seq. */
- _BT_CTF_FIELD_TYPE_INIT(seq_decl);
+ _BT_FIELD_TYPE_INIT(seq_decl);
char *length_name = concatenate_unary_strings(length);
+ char *length_name_no_underscore;
if (!length_name) {
_BT_LOGE_NODE(node_type_declarator,
goto error;
}
- seq_decl = bt_ctf_field_type_sequence_create(
- nested_decl, length_name);
+ length_name_no_underscore =
+ remove_underscores_from_field_ref(length_name);
+ if (!length_name_no_underscore) {
+ /* remove_underscores_from_field_ref() logs errors */
+ ret = -EINVAL;
+ goto error;
+ }
+ seq_decl = bt_field_type_sequence_create(
+ nested_decl, length_name_no_underscore);
+ free(length_name_no_underscore);
g_free(length_name);
BT_PUT(nested_decl);
if (!seq_decl) {
static
int visit_struct_decl_field(struct ctx *ctx,
- struct bt_ctf_field_type *struct_decl,
+ struct bt_field_type *struct_decl,
struct ctf_node *type_specifier_list,
struct bt_list_head *type_declarators)
{
int ret = 0;
struct ctf_node *iter;
- _BT_CTF_FIELD_TYPE_INIT(field_decl);
+ _BT_FIELD_TYPE_INIT(field_decl);
bt_list_for_each_entry(iter, type_declarators, siblings) {
field_decl = NULL;
GQuark qfield_name;
const char *field_name;
- _BT_CTF_FIELD_TYPE_INIT(efield_decl);
+ _BT_FIELD_TYPE_INIT(efield_decl);
ret = visit_type_declarator(ctx, type_specifier_list,
&qfield_name, iter, &field_decl, NULL);
/* Check if field with same name already exists */
efield_decl =
- bt_ctf_field_type_structure_get_field_type_by_name(
+ bt_field_type_structure_get_field_type_by_name(
struct_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
}
/* Add field to structure */
- ret = bt_ctf_field_type_structure_add_field(struct_decl,
+ ret = bt_field_type_structure_add_field(struct_decl,
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
static
int visit_variant_decl_field(struct ctx *ctx,
- struct bt_ctf_field_type *variant_decl,
+ struct bt_field_type *variant_decl,
struct ctf_node *type_specifier_list,
struct bt_list_head *type_declarators)
{
int ret = 0;
struct ctf_node *iter;
- _BT_CTF_FIELD_TYPE_INIT(field_decl);
+ _BT_FIELD_TYPE_INIT(field_decl);
bt_list_for_each_entry(iter, type_declarators, siblings) {
field_decl = NULL;
GQuark qfield_name;
const char *field_name;
- _BT_CTF_FIELD_TYPE_INIT(efield_decl);
+ _BT_FIELD_TYPE_INIT(efield_decl);
ret = visit_type_declarator(ctx, type_specifier_list,
&qfield_name, iter, &field_decl, NULL);
/* Check if field with same name already exists */
efield_decl =
- bt_ctf_field_type_variant_get_field_type_by_name(
+ bt_field_type_variant_get_field_type_by_name(
variant_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
}
/* Add field to structure */
- ret = bt_ctf_field_type_variant_add_field(variant_decl,
+ ret = bt_field_type_variant_add_field(variant_decl,
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
int ret = 0;
GQuark qidentifier;
struct ctf_node *iter;
- _BT_CTF_FIELD_TYPE_INIT(type_decl);
+ _BT_FIELD_TYPE_INIT(type_decl);
bt_list_for_each_entry(iter, type_declarators, siblings) {
ret = visit_type_declarator(ctx, type_specifier_list,
}
/* Do not allow typedef and typealias of untagged variants */
- if (bt_ctf_field_type_is_variant(type_decl)) {
- if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
+ if (bt_field_type_is_variant(type_decl)) {
+ if (bt_field_type_variant_get_tag_name(type_decl)) {
_BT_LOGE_NODE(iter,
"Type definition of untagged variant field type is not allowed.");
ret = -EPERM;
GQuark qalias;
struct ctf_node *node;
GQuark qdummy_field_name;
- _BT_CTF_FIELD_TYPE_INIT(type_decl);
+ _BT_FIELD_TYPE_INIT(type_decl);
/* Create target type declaration */
if (bt_list_empty(&target->u.typealias_target.type_declarators)) {
}
/* Do not allow typedef and typealias of untagged variants */
- if (bt_ctf_field_type_is_variant(type_decl)) {
- if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
- _BT_LOGE_NODE(node,
+ if (bt_field_type_is_variant(type_decl)) {
+ if (bt_field_type_variant_get_tag_name(type_decl)) {
+ _BT_LOGE_NODE(target,
"Type definition of untagged variant field type is not allowed.");
ret = -EPERM;
goto end;
* abstract or not (if it has an identifier). Check it here.
*/
if (qdummy_field_name != 0) {
- _BT_LOGE_NODE(node,
+ _BT_LOGE_NODE(target,
"Expecting empty identifier: id=\"%s\"",
g_quark_to_string(qdummy_field_name));
ret = -EINVAL;
static
int visit_struct_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_ctf_field_type *struct_decl)
+ struct bt_field_type *struct_decl)
{
int ret = 0;
static
int visit_variant_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_ctf_field_type *variant_decl)
+ struct bt_field_type *variant_decl)
{
int ret = 0;
int visit_struct_decl(struct ctx *ctx, const char *name,
struct bt_list_head *decl_list, int has_body,
struct bt_list_head *min_align,
- struct bt_ctf_field_type **struct_decl)
+ struct bt_field_type **struct_decl)
{
int ret = 0;
/* For named struct (without body), lookup in declaration scope */
if (!has_body) {
- _BT_CTF_FIELD_TYPE_INIT(struct_decl_copy);
+ _BT_FIELD_TYPE_INIT(struct_decl_copy);
if (!name) {
BT_LOGE_STR("Bodyless structure field type: missing name.");
}
/* Make a copy of it */
- struct_decl_copy = bt_ctf_field_type_copy(*struct_decl);
+ struct_decl_copy = bt_field_type_copy(*struct_decl);
if (!struct_decl_copy) {
BT_LOGE_STR("Cannot create copy of structure field type.");
ret = -EINVAL;
uint64_t min_align_value = 0;
if (name) {
- _BT_CTF_FIELD_TYPE_INIT(estruct_decl);
+ _BT_FIELD_TYPE_INIT(estruct_decl);
estruct_decl = ctx_decl_scope_lookup_struct(
ctx->current_scope, name, 1);
}
}
- *struct_decl = bt_ctf_field_type_structure_create();
+ *struct_decl = bt_field_type_structure_create();
if (!*struct_decl) {
BT_LOGE_STR("Cannot create empty structure field type.");
ret = -ENOMEM;
}
if (min_align_value != 0) {
- ret = bt_ctf_field_type_set_alignment(*struct_decl,
+ ret = bt_field_type_set_alignment(*struct_decl,
min_align_value);
if (ret) {
BT_LOGE("Cannot set structure field type's alignment: "
static
int visit_variant_decl(struct ctx *ctx, const char *name,
const char *tag, struct bt_list_head *decl_list,
- int has_body, struct bt_ctf_field_type **variant_decl)
+ int has_body, struct bt_field_type **variant_decl)
{
int ret = 0;
- _BT_CTF_FIELD_TYPE_INIT(untagged_variant_decl);
+ _BT_FIELD_TYPE_INIT(untagged_variant_decl);
*variant_decl = NULL;
/* For named variant (without body), lookup in declaration scope */
if (!has_body) {
- _BT_CTF_FIELD_TYPE_INIT(variant_decl_copy);
+ _BT_FIELD_TYPE_INIT(variant_decl_copy);
if (!name) {
BT_LOGE_STR("Bodyless variant field type: missing name.");
}
/* Make a copy of it */
- variant_decl_copy = bt_ctf_field_type_copy(
+ variant_decl_copy = bt_field_type_copy(
untagged_variant_decl);
if (!variant_decl_copy) {
BT_LOGE_STR("Cannot create copy of variant field type.");
struct ctf_node *entry_node;
if (name) {
- struct bt_ctf_field_type *evariant_decl =
+ struct bt_field_type *evariant_decl =
ctx_decl_scope_lookup_struct(ctx->current_scope,
name, 1);
}
}
- untagged_variant_decl = bt_ctf_field_type_variant_create(NULL,
+ untagged_variant_decl = bt_field_type_variant_create(NULL,
NULL);
if (!untagged_variant_decl) {
BT_LOGE_STR("Cannot create empty variant field type.");
* At this point, we have a fresh untagged variant; nobody
* else owns it. Set its tag now.
*/
- ret = bt_ctf_field_type_variant_set_tag_name(
- untagged_variant_decl, tag);
+ char *tag_no_underscore =
+ remove_underscores_from_field_ref(tag);
+
+ if (!tag_no_underscore) {
+ /* remove_underscores_from_field_ref() logs errors */
+ goto error;
+ }
+
+ ret = bt_field_type_variant_set_tag_name(
+ untagged_variant_decl, tag_no_underscore);
+ free(tag_no_underscore);
if (ret) {
BT_LOGE("Cannot set variant field type's tag name: "
"tag-name=\"%s\"", tag);
static
int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
- struct bt_ctf_field_type *enum_decl, int64_t *last, int is_signed)
+ struct bt_field_type *enum_decl, int64_t *last, bt_bool is_signed)
{
int ret = 0;
int nr_vals = 0;
struct ctf_node *iter;
int64_t start = 0, end = 0;
const char *label = enumerator->u.enumerator.id;
+ const char *effective_label = label;
struct bt_list_head *values = &enumerator->u.enumerator.values;
bt_list_for_each_entry(iter, values, siblings) {
*last = end + 1;
+ if (label[0] == '_') {
+ /*
+ * Strip the first underscore of any enumeration field
+ * type's label in case this enumeration FT is used as
+ * a variant FT tag later. The variant FT choice names
+ * could also start with `_`, in which case the prefix
+ * is removed, and it the resulting choice name needs to
+ * match tag labels.
+ */
+ effective_label = &label[1];
+ }
+
if (is_signed) {
- ret = bt_ctf_field_type_enumeration_add_mapping(enum_decl, label,
- start, end);
+ ret = bt_field_type_enumeration_add_mapping_signed(enum_decl,
+ effective_label, start, end);
} else {
- ret = bt_ctf_field_type_enumeration_add_mapping_unsigned(enum_decl,
- label, (uint64_t) start, (uint64_t) end);
+ ret = bt_field_type_enumeration_add_mapping_unsigned(enum_decl,
+ effective_label, (uint64_t) start, (uint64_t) end);
}
if (ret) {
_BT_LOGE_NODE(enumerator,
struct ctf_node *container_type,
struct bt_list_head *enumerator_list,
int has_body,
- struct bt_ctf_field_type **enum_decl)
+ struct bt_field_type **enum_decl)
{
int ret = 0;
GQuark qdummy_id;
- _BT_CTF_FIELD_TYPE_INIT(integer_decl);
+ _BT_FIELD_TYPE_INIT(integer_decl);
*enum_decl = NULL;
/* For named enum (without body), lookup in declaration scope */
if (!has_body) {
- _BT_CTF_FIELD_TYPE_INIT(enum_decl_copy);
+ _BT_FIELD_TYPE_INIT(enum_decl_copy);
if (!name) {
BT_LOGE_STR("Bodyless enumeration field type: missing name.");
}
/* Make a copy of it */
- enum_decl_copy = bt_ctf_field_type_copy(*enum_decl);
+ enum_decl_copy = bt_field_type_copy(*enum_decl);
if (!enum_decl_copy) {
BT_LOGE_STR("Cannot create copy of enumeration field type.");
ret = -EINVAL;
int64_t last_value = 0;
if (name) {
- _BT_CTF_FIELD_TYPE_INIT(eenum_decl);
+ _BT_FIELD_TYPE_INIT(eenum_decl);
eenum_decl = ctx_decl_scope_lookup_enum(
ctx->current_scope, name, 1);
assert(integer_decl);
- if (!bt_ctf_field_type_is_integer(integer_decl)) {
+ if (!bt_field_type_is_integer(integer_decl)) {
BT_LOGE("Container field type for enumeration field type is not an integer field type: "
"ft-id=%s",
- bt_ctf_field_type_id_string(
- bt_ctf_field_type_get_type_id(integer_decl)));
+ bt_field_type_id_string(
+ bt_field_type_get_type_id(integer_decl)));
ret = -EINVAL;
goto error;
}
- *enum_decl = bt_ctf_field_type_enumeration_create(integer_decl);
+ *enum_decl = bt_field_type_enumeration_create(integer_decl);
if (!*enum_decl) {
BT_LOGE_STR("Cannot create enumeration field type.");
ret = -ENOMEM;
bt_list_for_each_entry(iter, enumerator_list, siblings) {
ret = visit_enum_decl_entry(ctx, iter, *enum_decl,
&last_value,
- bt_ctf_field_type_integer_get_signed(integer_decl));
+ bt_field_type_integer_is_signed(integer_decl));
if (ret) {
_BT_LOGE_NODE(iter,
"Cannot visit enumeration field type entry: "
static
int visit_type_specifier(struct ctx *ctx,
struct ctf_node *type_specifier_list,
- struct bt_ctf_field_type **decl)
+ struct bt_field_type **decl)
{
int ret = 0;
GString *str = NULL;
- _BT_CTF_FIELD_TYPE_INIT(decl_copy);
+ _BT_FIELD_TYPE_INIT(decl_copy);
*decl = NULL;
str = g_string_new("");
}
/* Make a copy of the type declaration */
- decl_copy = bt_ctf_field_type_copy(*decl);
+ decl_copy = bt_field_type_copy(*decl);
if (!decl_copy) {
_BT_LOGE_NODE(type_specifier_list,
"Cannot create field type copy.");
static
int visit_integer_decl(struct ctx *ctx,
struct bt_list_head *expressions,
- struct bt_ctf_field_type **integer_decl)
+ struct bt_field_type **integer_decl)
{
int set = 0;
int ret = 0;
- int signedness = 0;
+ bt_bool signedness = 0;
struct ctf_node *expression;
uint64_t alignment = 0, size = 0;
- struct bt_ctf_clock_class *mapped_clock = NULL;
- enum bt_ctf_string_encoding encoding = BT_CTF_STRING_ENCODING_NONE;
- enum bt_ctf_integer_base base = BT_CTF_INTEGER_BASE_DECIMAL;
- enum bt_ctf_byte_order byte_order =
- bt_ctf_trace_get_native_byte_order(ctx->trace);
+ struct bt_clock_class *mapped_clock = NULL;
+ enum bt_string_encoding encoding = BT_STRING_ENCODING_NONE;
+ enum bt_integer_base base = BT_INTEGER_BASE_DECIMAL;
+ enum bt_byte_order byte_order =
+ bt_trace_get_native_byte_order(ctx->trace);
*integer_decl = NULL;
}
byte_order = get_real_byte_order(ctx, right);
- if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
+ if (byte_order == BT_BYTE_ORDER_UNKNOWN) {
_BT_LOGE_NODE(right,
"Invalid `byte_order` attribute in integer field type: "
"ret=%d", ret);
switch (constant) {
case 2:
- base = BT_CTF_INTEGER_BASE_BINARY;
+ base = BT_INTEGER_BASE_BINARY;
break;
case 8:
- base = BT_CTF_INTEGER_BASE_OCTAL;
+ base = BT_INTEGER_BASE_OCTAL;
break;
case 10:
- base = BT_CTF_INTEGER_BASE_DECIMAL;
+ base = BT_INTEGER_BASE_DECIMAL;
break;
case 16:
- base = BT_CTF_INTEGER_BASE_HEXADECIMAL;
+ base = BT_INTEGER_BASE_HEXADECIMAL;
break;
default:
_BT_LOGE_NODE(right,
!strcmp(s_right, "d") ||
!strcmp(s_right, "i") ||
!strcmp(s_right, "u")) {
- base = BT_CTF_INTEGER_BASE_DECIMAL;
+ base = BT_INTEGER_BASE_DECIMAL;
} else if (!strcmp(s_right, "hexadecimal") ||
!strcmp(s_right, "hex") ||
!strcmp(s_right, "x") ||
!strcmp(s_right, "X") ||
!strcmp(s_right, "p")) {
- base = BT_CTF_INTEGER_BASE_HEXADECIMAL;
+ base = BT_INTEGER_BASE_HEXADECIMAL;
} else if (!strcmp(s_right, "octal") ||
!strcmp(s_right, "oct") ||
!strcmp(s_right, "o")) {
- base = BT_CTF_INTEGER_BASE_OCTAL;
+ base = BT_INTEGER_BASE_OCTAL;
} else if (!strcmp(s_right, "binary") ||
!strcmp(s_right, "b")) {
- base = BT_CTF_INTEGER_BASE_BINARY;
+ base = BT_INTEGER_BASE_BINARY;
} else {
_BT_LOGE_NODE(right,
"Unexpected unary expression for integer field type's `base` attribute: "
!strcmp(s_right, "utf8") ||
!strcmp(s_right, "utf-8") ||
!strcmp(s_right, "UTF-8")) {
- encoding = BT_CTF_STRING_ENCODING_UTF8;
+ encoding = BT_STRING_ENCODING_UTF8;
} else if (!strcmp(s_right, "ASCII") ||
!strcmp(s_right, "ascii")) {
- encoding = BT_CTF_STRING_ENCODING_ASCII;
+ encoding = BT_STRING_ENCODING_ASCII;
} else if (!strcmp(s_right, "none")) {
- encoding = BT_CTF_STRING_ENCODING_NONE;
+ encoding = BT_STRING_ENCODING_NONE;
} else {
_BT_LOGE_NODE(right,
"Invalid `encoding` attribute in integer field type: "
continue;
}
- mapped_clock = bt_ctf_trace_get_clock_class_by_name(
+ mapped_clock = bt_trace_get_clock_class_by_name(
ctx->trace, clock_name);
if (!mapped_clock) {
_BT_LOGE_NODE(right,
}
}
- *integer_decl = bt_ctf_field_type_integer_create((unsigned int) size);
+ *integer_decl = bt_field_type_integer_create((unsigned int) size);
if (!*integer_decl) {
BT_LOGE_STR("Cannot create integer field type.");
ret = -ENOMEM;
goto error;
}
- ret = bt_ctf_field_type_integer_set_signed(*integer_decl, signedness);
- ret |= bt_ctf_field_type_integer_set_base(*integer_decl, base);
- ret |= bt_ctf_field_type_integer_set_encoding(*integer_decl, encoding);
- ret |= bt_ctf_field_type_set_alignment(*integer_decl,
+ ret = bt_field_type_integer_set_is_signed(*integer_decl, signedness);
+ ret |= bt_field_type_integer_set_base(*integer_decl, base);
+ ret |= bt_field_type_integer_set_encoding(*integer_decl, encoding);
+ ret |= bt_field_type_set_alignment(*integer_decl,
(unsigned int) alignment);
- ret |= bt_ctf_field_type_set_byte_order(*integer_decl, byte_order);
+ ret |= bt_field_type_set_byte_order(*integer_decl, byte_order);
if (mapped_clock) {
/* Move clock */
- ret |= bt_ctf_field_type_integer_set_mapped_clock_class(
+ ret |= bt_field_type_integer_set_mapped_clock_class(
*integer_decl, mapped_clock);
bt_put(mapped_clock);
mapped_clock = NULL;
static
int visit_floating_point_number_decl(struct ctx *ctx,
struct bt_list_head *expressions,
- struct bt_ctf_field_type **float_decl)
+ struct bt_field_type **float_decl)
{
int set = 0;
int ret = 0;
struct ctf_node *expression;
uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
- enum bt_ctf_byte_order byte_order =
- bt_ctf_trace_get_native_byte_order(ctx->trace);
+ enum bt_byte_order byte_order =
+ bt_trace_get_native_byte_order(ctx->trace);
*float_decl = NULL;
}
byte_order = get_real_byte_order(ctx, right);
- if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
+ if (byte_order == BT_BYTE_ORDER_UNKNOWN) {
_BT_LOGE_NODE(right,
"Invalid `byte_order` attribute in floating point number field type: "
"ret=%d", ret);
}
}
- *float_decl = bt_ctf_field_type_floating_point_create();
+ *float_decl = bt_field_type_floating_point_create();
if (!*float_decl) {
BT_LOGE_STR("Cannot create floating point number field type.");
ret = -ENOMEM;
goto error;
}
- ret = bt_ctf_field_type_floating_point_set_exponent_digits(
+ ret = bt_field_type_floating_point_set_exponent_digits(
*float_decl, exp_dig);
- ret |= bt_ctf_field_type_floating_point_set_mantissa_digits(
+ ret |= bt_field_type_floating_point_set_mantissa_digits(
*float_decl, mant_dig);
- ret |= bt_ctf_field_type_set_byte_order(*float_decl, byte_order);
- ret |= bt_ctf_field_type_set_alignment(*float_decl, alignment);
+ ret |= bt_field_type_set_byte_order(*float_decl, byte_order);
+ ret |= bt_field_type_set_alignment(*float_decl, alignment);
if (ret) {
BT_LOGE_STR("Cannot configure floating point number field type.");
ret = -EINVAL;
static
int visit_string_decl(struct ctx *ctx,
struct bt_list_head *expressions,
- struct bt_ctf_field_type **string_decl)
+ struct bt_field_type **string_decl)
{
int set = 0;
int ret = 0;
struct ctf_node *expression;
- enum bt_ctf_string_encoding encoding = BT_CTF_STRING_ENCODING_UTF8;
+ enum bt_string_encoding encoding = BT_STRING_ENCODING_UTF8;
*string_decl = NULL;
!strcmp(s_right, "utf8") ||
!strcmp(s_right, "utf-8") ||
!strcmp(s_right, "UTF-8")) {
- encoding = BT_CTF_STRING_ENCODING_UTF8;
+ encoding = BT_STRING_ENCODING_UTF8;
} else if (!strcmp(s_right, "ASCII") ||
!strcmp(s_right, "ascii")) {
- encoding = BT_CTF_STRING_ENCODING_ASCII;
+ encoding = BT_STRING_ENCODING_ASCII;
} else if (!strcmp(s_right, "none")) {
- encoding = BT_CTF_STRING_ENCODING_NONE;
+ encoding = BT_STRING_ENCODING_NONE;
} else {
_BT_LOGE_NODE(right,
"Invalid `encoding` attribute in string field type: "
}
}
- *string_decl = bt_ctf_field_type_string_create();
+ *string_decl = bt_field_type_string_create();
if (!*string_decl) {
BT_LOGE_STR("Cannot create string field type.");
ret = -ENOMEM;
goto error;
}
- ret = bt_ctf_field_type_string_set_encoding(*string_decl, encoding);
+ ret = bt_field_type_string_set_encoding(*string_decl, encoding);
if (ret) {
BT_LOGE_STR("Cannot configure string field type.");
ret = -EINVAL;
static
int visit_type_specifier_list(struct ctx *ctx,
struct ctf_node *ts_list,
- struct bt_ctf_field_type **decl)
+ struct bt_field_type **decl)
{
int ret = 0;
struct ctf_node *first, *node;
static
int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
- struct bt_ctf_event_class *event_class, int64_t *stream_id,
+ struct bt_event_class *event_class, int64_t *stream_id,
int *set)
{
int ret = 0;
char *left = NULL;
- _BT_CTF_FIELD_TYPE_INIT(decl);
+ _BT_FIELD_TYPE_INIT(decl);
switch (node->type) {
case NODE_TYPEDEF:
_SET(set, _EVENT_NAME_SET);
} else if (!strcmp(left, "id")) {
- int64_t id;
+ int64_t id = -1;
if (_IS_SET(set, _EVENT_ID_SET)) {
_BT_LOGE_DUP_ATTR(node, "id",
goto error;
}
- ret = bt_ctf_event_class_set_id(event_class, id);
+ ret = bt_event_class_set_id(event_class, id);
if (ret) {
_BT_LOGE_NODE(node,
"Cannot set event class's ID: "
}
assert(decl);
- ret = bt_ctf_event_class_set_context_type(
+ ret = bt_event_class_set_context_type(
event_class, decl);
BT_PUT(decl);
if (ret) {
}
assert(decl);
- ret = bt_ctf_event_class_set_payload_type(
+ ret = bt_event_class_set_payload_type(
event_class, decl);
BT_PUT(decl);
if (ret) {
_SET(set, _EVENT_FIELDS_SET);
} else if (!strcmp(left, "loglevel")) {
uint64_t loglevel_value;
- enum bt_ctf_event_class_log_level log_level =
- BT_CTF_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED;
+ enum bt_event_class_log_level log_level =
+ BT_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED;
if (_IS_SET(set, _EVENT_LOGLEVEL_SET)) {
_BT_LOGE_DUP_ATTR(node, "loglevel",
switch (loglevel_value) {
case 0:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_EMERGENCY;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY;
break;
case 1:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_ALERT;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_ALERT;
break;
case 2:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_CRITICAL;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL;
break;
case 3:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_ERROR;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_ERROR;
break;
case 4:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_WARNING;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_WARNING;
break;
case 5:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_NOTICE;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_NOTICE;
break;
case 6:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_INFO;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_INFO;
break;
case 7:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM;
break;
case 8:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM;
break;
case 9:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS;
break;
case 10:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE;
break;
case 11:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT;
break;
case 12:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION;
break;
case 13:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE;
break;
case 14:
- log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG;
+ log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG;
break;
default:
_BT_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
"log-level=%" PRIu64, loglevel_value);
}
- if (log_level != BT_CTF_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED) {
- ret = bt_ctf_event_class_set_log_level(
+ if (log_level != BT_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED) {
+ ret = bt_event_class_set_log_level(
event_class, log_level);
if (ret) {
_BT_LOGE_NODE(node,
_BT_LOGW_NODE(node,
"Not setting event class's EMF URI because it's empty.");
} else {
- ret = bt_ctf_event_class_set_emf_uri(
+ ret = bt_event_class_set_emf_uri(
event_class, right);
if (ret) {
_BT_LOGE_NODE(node,
static
int reset_event_decl_types(struct ctx *ctx,
- struct bt_ctf_event_class *event_class)
+ struct bt_event_class *event_class)
{
int ret = 0;
/* Context type. */
- ret = bt_ctf_event_class_set_context_type(event_class, NULL);
+ ret = bt_event_class_set_context_type(event_class, NULL);
if (ret) {
BT_LOGE("Cannot reset initial event class's context field type: "
"event-name=\"%s\"",
- bt_ctf_event_class_get_name(event_class));
+ bt_event_class_get_name(event_class));
goto end;
}
/* Event payload. */
- ret = bt_ctf_event_class_set_payload_type(event_class, NULL);
+ ret = bt_event_class_set_payload_type(event_class, NULL);
if (ret) {
BT_LOGE("Cannot reset initial event class's payload field type: "
"event-name=\"%s\"",
- bt_ctf_event_class_get_name(event_class));
+ bt_event_class_get_name(event_class));
goto end;
}
end:
static
int reset_stream_decl_types(struct ctx *ctx,
- struct bt_ctf_stream_class *stream_class)
+ struct bt_stream_class *stream_class)
{
int ret = 0;
/* Packet context. */
- ret = bt_ctf_stream_class_set_packet_context_type(stream_class, NULL);
+ ret = bt_stream_class_set_packet_context_type(stream_class, NULL);
if (ret) {
BT_LOGE_STR("Cannot reset initial stream class's packet context field type.");
goto end;
}
/* Event header. */
- ret = bt_ctf_stream_class_set_event_header_type(stream_class, NULL);
+ ret = bt_stream_class_set_event_header_type(stream_class, NULL);
if (ret) {
BT_LOGE_STR("Cannot reset initial stream class's event header field type.");
goto end;
}
/* Event context. */
- ret = bt_ctf_stream_class_set_event_context_type(stream_class, NULL);
+ ret = bt_stream_class_set_event_context_type(stream_class, NULL);
if (ret) {
BT_LOGE_STR("Cannot reset initial stream class's event context field type.");
goto end;
}
static
-struct bt_ctf_stream_class *create_reset_stream_class(struct ctx *ctx)
+struct bt_stream_class *create_reset_stream_class(struct ctx *ctx)
{
int ret;
- struct bt_ctf_stream_class *stream_class;
+ struct bt_stream_class *stream_class;
- stream_class = bt_ctf_stream_class_create_empty(NULL);
+ stream_class = bt_stream_class_create_empty(NULL);
if (!stream_class) {
BT_LOGE_STR("Cannot create empty stream class.");
goto error;
struct ctf_node *iter;
int64_t stream_id = -1;
char *event_name = NULL;
- struct bt_ctf_event_class *event_class = NULL;
- struct bt_ctf_event_class *eevent_class;
- struct bt_ctf_stream_class *stream_class = NULL;
+ struct bt_event_class *event_class = NULL;
+ struct bt_event_class *eevent_class;
+ struct bt_stream_class *stream_class = NULL;
struct bt_list_head *decl_list = &node->u.event.declaration_list;
bool pop_scope = false;
goto error;
}
- event_class = bt_ctf_event_class_create(event_name);
+ event_class = bt_event_class_create(event_name);
/*
* Unset context and fields to override the default ones.
if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) {
GList *keys = NULL;
- struct bt_ctf_stream_class *new_stream_class;
+ int64_t *new_stream_id;
+ struct bt_stream_class *new_stream_class;
size_t stream_class_count =
g_hash_table_size(ctx->stream_classes) +
- bt_ctf_trace_get_stream_class_count(ctx->trace);
+ bt_trace_get_stream_class_count(ctx->trace);
/*
* Allow missing stream_id if there is only a single
switch (stream_class_count) {
case 0:
/* Create implicit stream class if there's none */
+ stream_id = 0;
new_stream_class = create_reset_stream_class(ctx);
if (!new_stream_class) {
_BT_LOGE_NODE(node,
goto error;
}
- ret = bt_ctf_stream_class_set_id(new_stream_class, 0);
+ ret = bt_stream_class_set_id(new_stream_class,
+ stream_id);
if (ret) {
_BT_LOGE_NODE(node,
"Cannot set stream class's ID: "
goto error;
}
- stream_id = 0;
+ new_stream_id = g_new0(int64_t, 1);
+ if (!new_stream_id) {
+ BT_LOGE_STR("Failed to allocate a int64_t.");
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ *new_stream_id = stream_id;
/* Move reference to visitor's context */
g_hash_table_insert(ctx->stream_classes,
- (gpointer) stream_id, new_stream_class);
+ new_stream_id, new_stream_class);
+ new_stream_id = NULL;
new_stream_class = NULL;
break;
case 1:
/* Single stream class: get its ID */
if (g_hash_table_size(ctx->stream_classes) == 1) {
keys = g_hash_table_get_keys(ctx->stream_classes);
- stream_id = (int64_t) keys->data;
+ stream_id = *((int64_t *) keys->data);
g_list_free(keys);
} else {
- assert(bt_ctf_trace_get_stream_class_count(
+ assert(bt_trace_get_stream_class_count(
ctx->trace) == 1);
stream_class =
- bt_ctf_trace_get_stream_class_by_index(
+ bt_trace_get_stream_class_by_index(
ctx->trace, 0);
assert(stream_class);
- stream_id = bt_ctf_stream_class_get_id(
+ stream_id = bt_stream_class_get_id(
stream_class);
BT_PUT(stream_class);
}
assert(stream_id >= 0);
/* We have the stream ID now; get the stream class if found */
- stream_class = g_hash_table_lookup(ctx->stream_classes,
- (gpointer) stream_id);
+ stream_class = g_hash_table_lookup(ctx->stream_classes, &stream_id);
bt_get(stream_class);
if (!stream_class) {
- stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
+ stream_class = bt_trace_get_stream_class_by_id(ctx->trace,
stream_id);
if (!stream_class) {
_BT_LOGE_NODE(node,
if (!_IS_SET(&set, _EVENT_ID_SET)) {
/* Allow only one event without ID per stream */
- if (bt_ctf_stream_class_get_event_class_count(stream_class) !=
+ if (bt_stream_class_get_event_class_count(stream_class) !=
0) {
_BT_LOGE_NODE(node,
"Missing `id` attribute in event class.");
}
/* Automatic ID */
- ret = bt_ctf_event_class_set_id(event_class, 0);
+ ret = bt_event_class_set_id(event_class, 0);
if (ret) {
_BT_LOGE_NODE(node,
"Cannot set event class's ID: id=0, ret=%d",
}
}
- event_id = bt_ctf_event_class_get_id(event_class);
+ event_id = bt_event_class_get_id(event_class);
if (event_id < 0) {
_BT_LOGE_NODE(node, "Cannot get event class's ID.");
ret = -EINVAL;
goto error;
}
- eevent_class = bt_ctf_stream_class_get_event_class_by_id(stream_class,
+ eevent_class = bt_stream_class_get_event_class_by_id(stream_class,
event_id);
if (eevent_class) {
BT_PUT(eevent_class);
goto error;
}
- ret = bt_ctf_stream_class_add_event_class(stream_class, event_class);
+ ret = bt_stream_class_add_event_class(stream_class, event_class);
BT_PUT(event_class);
if (ret) {
_BT_LOGE_NODE(node,
static
int auto_map_field_to_trace_clock_class(struct ctx *ctx,
- struct bt_ctf_field_type *ft)
+ struct bt_field_type *ft)
{
- struct bt_ctf_clock_class *clock_class_to_map_to = NULL;
- struct bt_ctf_clock_class *mapped_clock_class = NULL;
+ struct bt_clock_class *clock_class_to_map_to = NULL;
+ struct bt_clock_class *mapped_clock_class = NULL;
int ret = 0;
int64_t clock_class_count;
- if (!ft || !bt_ctf_field_type_is_integer(ft)) {
+ if (!ft || !bt_field_type_is_integer(ft)) {
goto end;
}
mapped_clock_class =
- bt_ctf_field_type_integer_get_mapped_clock_class(ft);
+ bt_field_type_integer_get_mapped_clock_class(ft);
if (mapped_clock_class) {
goto end;
}
- clock_class_count = bt_ctf_trace_get_clock_class_count(ctx->trace);
+ clock_class_count = bt_trace_get_clock_class_count(ctx->trace);
assert(clock_class_count >= 0);
switch (clock_class_count) {
* point. Create an implicit one at 1 GHz,
* named `default`, and use this clock class.
*/
- clock_class_to_map_to = bt_ctf_clock_class_create("default");
+ clock_class_to_map_to = bt_clock_class_create("default",
+ 1000000000);
if (!clock_class_to_map_to) {
BT_LOGE_STR("Cannot create a clock class.");
ret = -1;
goto end;
}
- ret = bt_ctf_clock_class_set_frequency(clock_class_to_map_to,
- 1000000000);
- assert(ret == 0);
-
- ret = bt_ctf_trace_add_clock_class(ctx->trace,
+ ret = bt_trace_add_clock_class(ctx->trace,
clock_class_to_map_to);
if (ret) {
BT_LOGE_STR("Cannot add clock class to trace.");
* this point: use this one.
*/
clock_class_to_map_to =
- bt_ctf_trace_get_clock_class_by_index(ctx->trace, 0);
+ bt_trace_get_clock_class_by_index(ctx->trace, 0);
assert(clock_class_to_map_to);
break;
default:
}
assert(clock_class_to_map_to);
- ret = bt_ctf_field_type_integer_set_mapped_clock_class(ft,
+ ret = bt_field_type_integer_set_mapped_clock_class(ft,
clock_class_to_map_to);
if (ret) {
BT_LOGE("Cannot map field type's field to trace's clock class: "
"clock-class-name=\"%s\", ret=%d",
- bt_ctf_clock_class_get_name(clock_class_to_map_to),
+ bt_clock_class_get_name(clock_class_to_map_to),
ret);
goto end;
}
static
int auto_map_fields_to_trace_clock_class(struct ctx *ctx,
- struct bt_ctf_field_type *root_ft, const char *field_name)
+ struct bt_field_type *root_ft, const char *field_name)
{
int ret = 0;
int64_t i, count;
goto end;
}
- if (!bt_ctf_field_type_is_structure(root_ft) &&
- !bt_ctf_field_type_is_variant(root_ft)) {
+ if (!bt_field_type_is_structure(root_ft) &&
+ !bt_field_type_is_variant(root_ft)) {
goto end;
}
- if (bt_ctf_field_type_is_structure(root_ft)) {
- count = bt_ctf_field_type_structure_get_field_count(root_ft);
+ if (bt_field_type_is_structure(root_ft)) {
+ count = bt_field_type_structure_get_field_count(root_ft);
} else {
- count = bt_ctf_field_type_variant_get_field_count(root_ft);
+ count = bt_field_type_variant_get_field_count(root_ft);
}
assert(count >= 0);
for (i = 0; i < count; i++) {
- _BT_CTF_FIELD_TYPE_INIT(ft);
+ _BT_FIELD_TYPE_INIT(ft);
const char *name;
- if (bt_ctf_field_type_is_structure(root_ft)) {
- ret = bt_ctf_field_type_structure_get_field_by_index(
+ if (bt_field_type_is_structure(root_ft)) {
+ ret = bt_field_type_structure_get_field_by_index(
root_ft, &name, &ft, i);
- } else if (bt_ctf_field_type_is_variant(root_ft)) {
- ret = bt_ctf_field_type_variant_get_field_by_index(
+ } else if (bt_field_type_is_variant(root_ft)) {
+ ret = bt_field_type_variant_get_field_by_index(
root_ft, &name, &ft, i);
}
static
int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
- struct bt_ctf_stream_class *stream_class, int *set)
+ struct bt_stream_class *stream_class, int *set)
{
int ret = 0;
char *left = NULL;
- _BT_CTF_FIELD_TYPE_INIT(decl);
+ _BT_FIELD_TYPE_INIT(decl);
switch (node->type) {
case NODE_TYPEDEF:
goto error;
}
- ptr = g_hash_table_lookup(ctx->stream_classes,
- (gpointer) id);
+ ptr = g_hash_table_lookup(ctx->stream_classes, &id);
if (ptr) {
_BT_LOGE_NODE(node,
"Duplicate stream class (same ID): id=%" PRId64,
goto error;
}
- ret = bt_ctf_stream_class_set_id(stream_class, id);
+ ret = bt_stream_class_set_id(stream_class, id);
if (ret) {
_BT_LOGE_NODE(node,
"Cannot set stream class's ID: "
goto error;
}
- ret = bt_ctf_stream_class_set_event_header_type(
+ ret = bt_stream_class_set_event_header_type(
stream_class, decl);
BT_PUT(decl);
if (ret) {
assert(decl);
- ret = bt_ctf_stream_class_set_event_context_type(
+ ret = bt_stream_class_set_event_context_type(
stream_class, decl);
BT_PUT(decl);
if (ret) {
goto error;
}
- ret = bt_ctf_stream_class_set_packet_context_type(
+ ret = bt_stream_class_set_packet_context_type(
stream_class, decl);
BT_PUT(decl);
if (ret) {
int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
{
int64_t id;
+ int64_t *new_id;
int set = 0;
int ret = 0;
struct ctf_node *iter;
- struct bt_ctf_stream_class *stream_class = NULL;
- struct bt_ctf_stream_class *existing_stream_class = NULL;
+ struct bt_stream_class *stream_class = NULL;
+ struct bt_stream_class *existing_stream_class = NULL;
struct bt_list_head *decl_list = &node->u.stream.declaration_list;
if (node->visited) {
if (_IS_SET(&set, _STREAM_ID_SET)) {
/* Check that packet header has stream_id field */
- _BT_CTF_FIELD_TYPE_INIT(stream_id_decl);
- _BT_CTF_FIELD_TYPE_INIT(packet_header_decl);
+ _BT_FIELD_TYPE_INIT(stream_id_decl);
+ _BT_FIELD_TYPE_INIT(packet_header_decl);
packet_header_decl =
- bt_ctf_trace_get_packet_header_type(ctx->trace);
+ bt_trace_get_packet_header_type(ctx->trace);
if (!packet_header_decl) {
_BT_LOGE_NODE(node,
"Stream class has a `id` attribute, "
}
stream_id_decl =
- bt_ctf_field_type_structure_get_field_type_by_name(
+ bt_field_type_structure_get_field_type_by_name(
packet_header_decl, "stream_id");
BT_PUT(packet_header_decl);
if (!stream_id_decl) {
goto error;
}
- if (!bt_ctf_field_type_is_integer(stream_id_decl)) {
+ if (!bt_field_type_is_integer(stream_id_decl)) {
BT_PUT(stream_id_decl);
_BT_LOGE_NODE(node,
"Stream class has a `id` attribute, "
}
/* Automatic ID: 0 */
- ret = bt_ctf_stream_class_set_id(stream_class, 0);
+ ret = bt_stream_class_set_id(stream_class, 0);
assert(ret == 0);
}
- id = bt_ctf_stream_class_get_id(stream_class);
+ id = bt_stream_class_get_id(stream_class);
if (id < 0) {
_BT_LOGE_NODE(node,
"Cannot get stream class's ID.");
* Make sure that this stream class's ID is currently unique in
* the trace.
*/
- existing_stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
+ existing_stream_class = bt_trace_get_stream_class_by_id(ctx->trace,
id);
- if (g_hash_table_lookup(ctx->stream_classes, (gpointer) id) ||
+ if (g_hash_table_lookup(ctx->stream_classes, &id) ||
existing_stream_class) {
_BT_LOGE_NODE(node,
"Duplicate stream class (same ID): id=%" PRId64,
goto error;
}
+ new_id = g_new0(int64_t, 1);
+ if (!new_id) {
+ BT_LOGE_STR("Failed to allocate a int64_t.");
+ ret = -ENOMEM;
+ goto error;
+ }
+ *new_id = id;
+
/* Move reference to visitor's context */
- g_hash_table_insert(ctx->stream_classes, (gpointer) (int64_t) id,
+ g_hash_table_insert(ctx->stream_classes, new_id,
stream_class);
stream_class = NULL;
goto end;
{
int ret = 0;
char *left = NULL;
- _BT_CTF_FIELD_TYPE_INIT(packet_header_decl);
+ _BT_FIELD_TYPE_INIT(packet_header_decl);
switch (node->type) {
case NODE_TYPEDEF:
goto error;
}
- ret = bt_ctf_trace_set_uuid(ctx->trace, ctx->trace_uuid);
+ ret = bt_trace_set_uuid(ctx->trace, ctx->trace_uuid);
if (ret) {
_BT_LOGE_NODE(node, "Cannot set trace's UUID.");
goto error;
}
assert(packet_header_decl);
- ret = bt_ctf_trace_set_packet_header_type(ctx->trace,
+ ret = bt_trace_set_packet_header_type(ctx->trace,
packet_header_decl);
BT_PUT(packet_header_decl);
if (ret) {
}
}
- ret = bt_ctf_trace_set_environment_field_string(
+ ret = bt_trace_set_environment_field_string(
ctx->trace, left, right);
g_free(right);
goto error;
}
- ret = bt_ctf_trace_set_environment_field_integer(
+ ret = bt_trace_set_environment_field_integer(
ctx->trace, left, v);
if (ret) {
_BT_LOGE_NODE(entry_node,
}
if (!strcmp(left, "byte_order")) {
- enum bt_ctf_byte_order bo;
+ enum bt_byte_order bo;
if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
_BT_LOGE_DUP_ATTR(node, "byte_order",
&node->u.ctf_expression.right,
struct ctf_node, siblings);
bo = byte_order_from_unary_expr(right_node);
- if (bo == BT_CTF_BYTE_ORDER_UNKNOWN) {
+ if (bo == BT_BYTE_ORDER_UNKNOWN) {
_BT_LOGE_NODE(node,
"Invalid `byte_order` attribute in trace (`trace` block): "
"expecting `le`, `be`, or `network`.");
ret = -EINVAL;
goto error;
- } else if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
+ } else if (bo == BT_BYTE_ORDER_NATIVE) {
_BT_LOGE_NODE(node,
"Invalid `byte_order` attribute in trace (`trace` block): "
"cannot be set to `native` here.");
}
ctx->trace_bo = bo;
- ret = bt_ctf_trace_set_native_byte_order(
+ ret = bt_trace_set_native_byte_order(
ctx->trace, bo);
if (ret) {
_BT_LOGE_NODE(node,
static
int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_ctf_clock_class *clock, int *set)
+ struct bt_clock_class *clock, int *set)
{
int ret = 0;
char *left = NULL;
goto error;
}
- ret = bt_ctf_clock_class_set_name(clock, right);
+ ret = bt_clock_class_set_name(clock, right);
if (ret) {
_BT_LOGE_NODE(entry_node,
"cannot set clock class's name");
goto error;
}
- ret = bt_ctf_clock_class_set_uuid(clock, uuid);
+ ret = bt_clock_class_set_uuid(clock, uuid);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's UUID.");
goto error;
}
- ret = bt_ctf_clock_class_set_description(clock, right);
+ ret = bt_clock_class_set_description(clock, right);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's description.");
g_free(right);
_SET(set, _CLOCK_DESCRIPTION_SET);
} else if (!strcmp(left, "freq")) {
- uint64_t freq;
+ uint64_t freq = -1ULL;
if (_IS_SET(set, _CLOCK_FREQ_SET)) {
_BT_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
goto error;
}
- ret = bt_ctf_clock_class_set_frequency(clock, freq);
+ if (freq == -1ULL || freq == 0) {
+ _BT_LOGE_NODE(entry_node,
+ "Invalid clock class frequency: freq=%" PRIu64,
+ freq);
+ ret = -EINVAL;
+ goto error;
+ }
+
+ ret = bt_clock_class_set_frequency(clock, freq);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's frequency.");
goto error;
}
- ret = bt_ctf_clock_class_set_precision(clock, precision);
+ ret = bt_clock_class_set_precision(clock, precision);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's precision.");
_SET(set, _CLOCK_PRECISION_SET);
} else if (!strcmp(left, "offset_s")) {
- uint64_t offset_s;
+ int64_t offset_s;
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
_BT_LOGE_DUP_ATTR(entry_node, "offset_s",
goto error;
}
- ret = get_unary_unsigned(
+ ret = get_unary_signed(
&entry_node->u.ctf_expression.right, &offset_s);
if (ret) {
_BT_LOGE_NODE(entry_node,
goto error;
}
- ret = bt_ctf_clock_class_set_offset_s(clock, offset_s);
+ ret = bt_clock_class_set_offset_s(clock, offset_s);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's offset in seconds.");
_SET(set, _CLOCK_OFFSET_S_SET);
} else if (!strcmp(left, "offset")) {
- uint64_t offset;
+ int64_t offset;
if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
_BT_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
goto error;
}
- ret = get_unary_unsigned(
+ ret = get_unary_signed(
&entry_node->u.ctf_expression.right, &offset);
if (ret) {
_BT_LOGE_NODE(entry_node,
goto error;
}
- ret = bt_ctf_clock_class_set_offset_cycles(clock, offset);
+ ret = bt_clock_class_set_offset_cycles(clock, offset);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's offset in cycles.");
goto error;
}
- ret = bt_ctf_clock_class_set_is_absolute(clock, ret);
+ ret = bt_clock_class_set_is_absolute(clock, ret);
if (ret) {
_BT_LOGE_NODE(entry_node,
"Cannot set clock class's absolute flag.");
}
static
-int apply_clock_class_offset(struct ctx *ctx, struct bt_ctf_clock_class *clock)
+int apply_clock_class_offset(struct ctx *ctx, struct bt_clock_class *clock)
{
int ret;
uint64_t freq;
int64_t offset_cycles;
int64_t offset_to_apply;
- freq = bt_ctf_clock_class_get_frequency(clock);
+ freq = bt_clock_class_get_frequency(clock);
if (freq == -1ULL) {
BT_LOGE_STR("Cannot get clock class's frequency.");
ret = -1;
goto end;
}
- ret = bt_ctf_clock_class_get_offset_cycles(clock, &offset_cycles);
+ ret = bt_clock_class_get_offset_cycles(clock, &offset_cycles);
if (ret) {
BT_LOGE_STR("Cannot get clock class's offset in cycles.");
ret = -1;
ctx->decoder_config.clock_class_offset_s * 1000000000LL +
ctx->decoder_config.clock_class_offset_ns;
offset_cycles += cycles_from_ns(freq, offset_to_apply);
- ret = bt_ctf_clock_class_set_offset_cycles(clock, offset_cycles);
+ ret = bt_clock_class_set_offset_cycles(clock, offset_cycles);
end:
return ret;
{
int ret = 0;
int set = 0;
- struct bt_ctf_clock_class *clock;
+ struct bt_clock_class *clock;
struct ctf_node *entry_node;
struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list;
const char *clock_class_name;
}
clock_node->visited = TRUE;
- clock = bt_ctf_clock_class_create(NULL);
+
+ /* CTF 1.8's default frequency for a clock class is 1 GHz */
+ clock = bt_clock_class_create(NULL, 1000000000);
if (!clock) {
_BT_LOGE_NODE(clock_node,
"Cannot create default clock class.");
goto error;
}
- clock_class_name = bt_ctf_clock_class_get_name(clock);
+ clock_class_name = bt_clock_class_get_name(clock);
assert(clock_class_name);
if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) {
/*
* it's a condition to be able to sort notifications
* from different sources.
*/
- ret = bt_ctf_clock_class_set_is_absolute(clock, 1);
+ ret = bt_clock_class_set_is_absolute(clock, 1);
if (ret) {
_BT_LOGE_NODE(clock_node,
"Cannot set clock class's absolute flag.");
goto error;
}
- ret = bt_ctf_trace_add_clock_class(ctx->trace, clock);
+ ret = bt_trace_add_clock_class(ctx->trace, clock);
if (ret) {
_BT_LOGE_NODE(clock_node,
"Cannot add clock class to trace.");
break;
case NODE_TYPE_SPECIFIER_LIST:
{
- _BT_CTF_FIELD_TYPE_INIT(decl);
+ _BT_FIELD_TYPE_INIT(decl);
/*
* Just add the type specifier to the root
int ret = 0;
struct bt_value *value = NULL;
- assert(bt_ctf_trace_get_stream_class_count(ctx->trace) == 0);
+ assert(bt_trace_get_stream_class_count(ctx->trace) == 0);
name = g_string_new(NULL);
if (!name) {
BT_LOGE_STR("Failed to allocate a GString.");
* Check if we have a trace environment string value named `hostname`.
* If so, use it as the trace name's prefix.
*/
- value = bt_ctf_trace_get_environment_field_value_by_name(ctx->trace,
+ value = bt_trace_get_environment_field_value_by_name(ctx->trace,
"hostname");
if (bt_value_is_string(value)) {
const char *hostname;
g_string_append(name, ctx->trace_name_suffix);
}
- ret = bt_ctf_trace_set_name(ctx->trace, name->str);
+ ret = bt_trace_set_name(ctx->trace, name->str);
if (ret) {
BT_LOGE("Cannot set trace's name: name=\"%s\"", name->str);
goto error;
gpointer key, stream_class;
if (g_hash_table_size(ctx->stream_classes) > 0 &&
- bt_ctf_trace_get_stream_class_count(ctx->trace) == 0) {
+ bt_trace_get_stream_class_count(ctx->trace) == 0) {
/*
* We're about to add the first stream class to the
* trace. This will freeze the trace, and after this
g_hash_table_iter_init(&iter, ctx->stream_classes);
while (g_hash_table_iter_next(&iter, &key, &stream_class)) {
- ret = bt_ctf_trace_add_stream_class(ctx->trace,
+ ret = bt_trace_add_stream_class(ctx->trace,
stream_class);
if (ret) {
- int64_t id = bt_ctf_stream_class_get_id(stream_class);
+ int64_t id = bt_stream_class_get_id(stream_class);
BT_LOGE("Cannot add stream class to trace: id=%" PRId64,
id);
goto end;
{
int ret;
struct ctx *ctx = NULL;
- struct bt_ctf_trace *trace;
+ struct bt_trace *trace;
- trace = bt_ctf_trace_create();
+ trace = bt_trace_create();
if (!trace) {
BT_LOGE_STR("Cannot create empty trace.");
goto error;
}
/* Set packet header to NULL to override the default one */
- ret = bt_ctf_trace_set_packet_header_type(trace, NULL);
+ ret = bt_trace_set_packet_header_type(trace, NULL);
if (ret) {
BT_LOGE_STR("Cannot reset initial trace's packet header field type.");
goto error;
}
BT_HIDDEN
-struct bt_ctf_trace *ctf_visitor_generate_ir_get_trace(
+struct bt_trace *ctf_visitor_generate_ir_get_trace(
struct ctf_visitor_generate_ir *visitor)
{
struct ctx *ctx = (void *) visitor;
* have the native byte order yet, and we don't have any
* trace block yet, then fail with EINCOMPLETE.
*/
- if (ctx->trace_bo == BT_CTF_BYTE_ORDER_NATIVE) {
+ if (ctx->trace_bo == BT_BYTE_ORDER_NATIVE) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
if (got_trace_decl) {
_BT_LOGE_NODE(node,
}
}
- assert(ctx->trace_bo == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ||
- ctx->trace_bo == BT_CTF_BYTE_ORDER_BIG_ENDIAN);
+ assert(ctx->trace_bo == BT_BYTE_ORDER_LITTLE_ENDIAN ||
+ ctx->trace_bo == BT_BYTE_ORDER_BIG_ENDIAN);
assert(ctx->current_scope &&
ctx->current_scope->parent_scope == NULL);
projects / babeltrace.git / blobdiff