bt_list_for_each_entry(node, head, siblings) {
if (node->type != NODE_UNARY_EXPRESSION
- || node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
|| (node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT && node->u.unary_expression.type != UNARY_SIGNED_CONSTANT)
|| node->u.unary_expression.link != UNARY_LINK_UNKNOWN
|| i != 0)
|| i != 0)
return -EINVAL;
src_string = node->u.unary_expression.u.string;
- ret = babeltrace_uuid_parse(src_string, uuid);
+ ret = bt_uuid_parse(src_string, uuid);
}
return ret;
}
return g_ptr_array_index(trace->streams, stream_id);
}
+static
+struct ctf_event_declaration *stream_event_lookup(struct ctf_stream_declaration *stream, uint64_t event_id)
+{
+ if (stream->events_by_id->len <= event_id)
+ return NULL;
+ return g_ptr_array_index(stream->events_by_id, event_id);
+}
+
static
struct ctf_clock *trace_clock_lookup(struct ctf_trace *trace, GQuark clock_name)
{
bt_list_for_each_entry(iter, type_declarators, siblings) {
struct bt_declaration *type_declaration;
int ret;
-
+
type_declaration = ctf_type_declarator_visit(fd, depth,
type_specifier_list,
&identifier, iter,
if (name) {
if (bt_lookup_struct_declaration(g_quark_from_string(name),
declaration_scope)) {
-
fprintf(fd, "[error] %s: struct %s already declared in scope\n", __func__, name);
return NULL;
}
ret = get_unary_unsigned(min_align, &min_align_value);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for structure \"align\" attribute\n", __func__);
- ret = -EINVAL;
goto error;
}
}
if (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;
}
q = g_quark_from_string(enumerator->u.enumerator.id);
if (enum_declaration->integer_declaration->signedness) {
- int64_t start, end;
+ int64_t start = 0, end = 0;
int nr_vals = 0;
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
last->u.s = end + 1;
bt_enum_signed_insert(enum_declaration, start, end, q);
} else {
- uint64_t start, end;
+ uint64_t start = 0, end = 0;
int nr_vals = 0;
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
if (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);
return NULL;
}
fprintf(fd, "[error] %s: unexpected unary expression type\n",
__func__);
return -EINVAL;
- }
+ }
}
return NULL;
}
size = right->u.unary_expression.u.unsigned_constant;
+ if (!size) {
+ fprintf(fd, "[error] %s: integer size: expecting non-zero constant\n",
+ __func__);
+ return NULL;
+ }
has_size = 1;
} else if (!strcmp(left->u.unary_expression.u.string, "align")) {
if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
struct ctf_trace *trace)
{
struct ctf_node *expression;
- uint64_t alignment = 1, exp_dig = 0, mant_dig = 0,
- byte_order = trace->byte_order;
- int has_alignment = 0, has_exp_dig = 0, has_mant_dig = 0;
+ uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
+ int byte_order = trace->byte_order, has_alignment = 0,
+ has_exp_dig = 0, has_mant_dig = 0;
struct declaration_float *float_declaration;
bt_list_for_each_entry(expression, expressions, siblings) {
struct ctf_event_declaration *event;
struct bt_ctf_event_decl *event_decl;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
event_decl = g_new0(struct bt_ctf_event_decl, 1);
event = &event_decl->parent;
event->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
fprintf(fd, "[error] %s: missing id field in event declaration\n", __func__);
goto error;
}
+ /* Disallow re-using the same event ID in the same stream */
+ if (stream_event_lookup(event->stream, event->id)) {
+ ret = -EPERM;
+ fprintf(fd, "[error] %s: event ID %" PRIu64 " used more than once in stream %" PRIu64 "\n",
+ __func__, event->id, event->stream_id);
+ goto error;
+ }
if (event->stream->events_by_id->len <= event->id)
g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
g_ptr_array_index(event->stream->events_by_id, event->id) = event;
struct ctf_node *iter;
struct ctf_stream_declaration *stream;
+ if (node) {
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+ }
+
stream = g_new0(struct ctf_stream_declaration, 1);
stream->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
stream->events_by_id = g_ptr_array_new();
goto error;
}
if (CTF_TRACE_FIELD_IS_SET(trace, uuid)
- && babeltrace_uuid_compare(uuid, trace->uuid)) {
+ && bt_uuid_compare(uuid, trace->uuid)) {
fprintf(fd, "[error] %s: uuid mismatch\n", __func__);
ret = -EPERM;
goto error;
int ret = 0;
struct ctf_node *iter;
+ if (!trace->restart_root_decl && node->visited)
+ return 0;
+ node->visited = 1;
+
if (trace->declaration_scope)
return -EEXIST;
+
trace->declaration_scope = bt_new_declaration_scope(trace->root_declaration_scope);
trace->streams = g_ptr_array_new();
trace->event_declarations = g_ptr_array_new();
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(&node->u.ctf_expression.right, &clock->offset_s);
+ ret = get_unary_signed(&node->u.ctf_expression.right, &clock->offset_s);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for clock offset_s\n", __func__);
ret = -EINVAL;
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(&node->u.ctf_expression.right, &clock->offset);
+ ret = get_unary_signed(&node->u.ctf_expression.right, &clock->offset);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for clock offset\n", __func__);
ret = -EINVAL;
goto error;
}
clock->absolute = ret;
+ ret = 0;
} else {
fprintf(fd, "[warning] %s: attribute \"%s\" is unknown in clock declaration.\n", __func__, left);
}
struct ctf_node *iter;
struct ctf_clock *clock;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
clock = g_new0(struct ctf_clock, 1);
/* Default clock frequency is set to 1000000000 */
clock->freq = 1000000000ULL;
struct ctf_callsite *callsite;
struct ctf_callsite_dups *cs_dups;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
callsite = g_new0(struct ctf_callsite, 1);
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
ret = ctf_callsite_declaration_visit(fd, depth + 1, iter, callsite, trace);
int ret = 0;
struct ctf_node *iter;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
trace->env.vpid = -1;
trace->env.procname[0] = '\0';
trace->env.hostname[0] = '\0';
{
int ret = 0;
+ if (!trace->restart_root_decl && node->visited)
+ return 0;
+ node->visited = 1;
+
switch (node->type) {
case NODE_TYPEDEF:
ret = ctf_typedef_visit(fd, depth + 1,
{
int ret = 0;
struct ctf_node *iter;
- int env_clock_done = 0;
printf_verbose("CTF visitor: metadata construction...\n");
trace->byte_order = byte_order;
switch (node->type) {
case NODE_ROOT:
- if (!env_clock_done) {
- /*
- * declarations need to query clock hash table,
- * so clock need to be treated first.
- */
- if (bt_list_empty(&node->u.root.clock)) {
- ctf_clock_default(fd, depth + 1, trace);
- } else {
- bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
- ret = ctf_clock_visit(fd, depth + 1, iter,
- trace);
- if (ret) {
- fprintf(fd, "[error] %s: clock declaration error\n", __func__);
- goto error;
- }
+ /*
+ * declarations need to query clock hash table,
+ * so clock need to be treated first.
+ */
+ if (bt_list_empty(&node->u.root.clock)) {
+ ctf_clock_default(fd, depth + 1, trace);
+ } else {
+ bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
+ ret = ctf_clock_visit(fd, depth + 1, iter,
+ trace);
+ if (ret) {
+ fprintf(fd, "[error] %s: clock declaration error\n", __func__);
+ goto error;
}
}
- env_clock_done = 1;
}
bt_list_for_each_entry(iter, &node->u.root.declaration_list,
siblings) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = ctf_trace_visit(fd, depth + 1, iter, trace);
if (ret == -EINTR) {
+ trace->restart_root_decl = 1;
bt_free_declaration_scope(trace->root_declaration_scope);
/*
* Need to restart creation of type
goto error;
}
}
+ trace->restart_root_decl = 0;
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
ret = ctf_callsite_visit(fd, depth + 1, iter,
trace);
projects / babeltrace.git / blobdiff