#include <babeltrace/list.h>
#include <babeltrace/types.h>
#include <babeltrace/ctf/metadata.h>
-#include <babeltrace/uuid.h>
+#include <babeltrace/compat/uuid.h>
#include <babeltrace/endian.h>
#include <babeltrace/ctf/events-internal.h>
#include "ctf-scanner.h"
bt_list_for_each_entry(node, head, siblings) {
char *src_string;
- assert(node->type == NODE_UNARY_EXPRESSION);
- assert(node->u.unary_expression.type == UNARY_STRING);
- assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
- ^ (i != 0));
+ if (node->type != NODE_UNARY_EXPRESSION
+ || node->u.unary_expression.type != UNARY_STRING
+ || !((node->u.unary_expression.link != UNARY_LINK_UNKNOWN)
+ ^ (i == 0)))
+ return NULL;
switch (node->u.unary_expression.link) {
case UNARY_DOTLINK:
g_string_append(str, ".");
bt_list_for_each_entry(node, head, siblings) {
char *src_string;
- assert(node->type == NODE_UNARY_EXPRESSION);
- assert(node->u.unary_expression.type == UNARY_STRING);
- assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
- ^ (i != 0));
+ if (node->type != NODE_UNARY_EXPRESSION
+ || node->u.unary_expression.type != UNARY_STRING
+ || !((node->u.unary_expression.link != UNARY_LINK_UNKNOWN)
+ ^ (i == 0)))
+ return 0;
/* needs to be chained with . */
switch (node->u.unary_expression.link) {
case UNARY_DOTLINK:
int i = 0;
bt_list_for_each_entry(node, head, siblings) {
- assert(node->type == NODE_UNARY_EXPRESSION);
- assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
- assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
- assert(i == 0);
+ if (node->type != NODE_UNARY_EXPRESSION
+ || node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
+ || node->u.unary_expression.link != UNARY_LINK_UNKNOWN
+ || i != 0)
+ return -EINVAL;
*value = node->u.unary_expression.u.unsigned_constant;
i++;
}
int i = 0;
bt_list_for_each_entry(node, head, siblings) {
- assert(node->type == NODE_UNARY_EXPRESSION);
- assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT
- || node->u.unary_expression.type == UNARY_SIGNED_CONSTANT);
- assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
- assert(i == 0);
+ 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)
+ return -EINVAL;
switch (node->u.unary_expression.type) {
case UNARY_UNSIGNED_CONSTANT:
*value = (int64_t) node->u.unary_expression.u.unsigned_constant;
*value = node->u.unary_expression.u.signed_constant;
break;
default:
- assert(0);
+ return -EINVAL;
}
i++;
}
bt_list_for_each_entry(node, head, siblings) {
const char *src_string;
- assert(node->type == NODE_UNARY_EXPRESSION);
- assert(node->u.unary_expression.type == UNARY_STRING);
- assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
- assert(i == 0);
+ if (node->type != NODE_UNARY_EXPRESSION
+ || node->u.unary_expression.type != UNARY_STRING
+ || node->u.unary_expression.link != UNARY_LINK_UNKNOWN
+ || i != 0)
+ return -EINVAL;
src_string = node->u.unary_expression.u.string;
ret = babeltrace_uuid_parse(src_string, uuid);
}
static
struct ctf_clock *trace_clock_lookup(struct ctf_trace *trace, GQuark clock_name)
{
- return g_hash_table_lookup(trace->clocks, (gpointer) (unsigned long) clock_name);
+ return g_hash_table_lookup(trace->parent.clocks, (gpointer) (unsigned long) clock_name);
}
static
int visit_type_specifier(FILE *fd, struct ctf_node *type_specifier, GString *str)
{
- assert(type_specifier->type == NODE_TYPE_SPECIFIER);
+ if (type_specifier->type != NODE_TYPE_SPECIFIER)
+ return -EINVAL;
switch (type_specifier->u.type_specifier.type) {
case TYPESPEC_VOID:
*/
if (node_type_declarator) {
- assert(node_type_declarator->u.type_declarator.type != TYPEDEC_UNKNOWN);
+ if (node_type_declarator->u.type_declarator.type == TYPEDEC_UNKNOWN) {
+ return NULL;
+ }
/* TODO: gcc bitfields not supported yet. */
if (node_type_declarator->u.type_declarator.bitfield_len != NULL) {
}
first = _bt_list_first_entry(&node_type_declarator->u.type_declarator.u.nested.length,
struct ctf_node, siblings);
- assert(first->type == NODE_UNARY_EXPRESSION);
+ if (first->type != NODE_UNARY_EXPRESSION) {
+ return NULL;
+ }
switch (first->u.unary_expression.type) {
case UNARY_UNSIGNED_CONSTANT:
char *length_name = concatenate_unary_strings(&node_type_declarator->u.type_declarator.u.nested.length);
struct declaration_sequence *sequence_declaration;
+ if (!length_name)
+ return NULL;
sequence_declaration = bt_sequence_declaration_new(length_name, nested_declaration, declaration_scope);
if (!sequence_declaration) {
fprintf(fd, "[error] %s: cannot create sequence declaration.\n", __func__);
break;
}
default:
- assert(0);
+ return NULL;
}
/* Pass it as content of outer container */
break;
default:
fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
- assert(0);
+ return -EINVAL;
}
return 0;
}
break;
default:
fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
- assert(0);
+ return -EINVAL;
}
return 0;
}
* declaration: ref is only taken upon definition.
*/
if (!has_body) {
- assert(name);
+ if (!name)
+ return NULL;
struct_declaration =
bt_lookup_struct_declaration(g_quark_from_string(name),
declaration_scope);
ret = bt_register_struct_declaration(g_quark_from_string(name),
struct_declaration,
declaration_scope);
- assert(!ret);
+ if (ret)
+ return NULL;
}
return &struct_declaration->p;
}
* declaration: ref is only taken upon definition.
*/
if (!has_body) {
- assert(name);
+ if (!name)
+ return NULL;
untagged_variant_declaration =
bt_lookup_variant_declaration(g_quark_from_string(name),
declaration_scope);
ret = bt_register_variant_declaration(g_quark_from_string(name),
untagged_variant_declaration,
declaration_scope);
- assert(!ret);
+ if (ret)
+ return NULL;
}
}
/*
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
int64_t *target;
- assert(iter->type == NODE_UNARY_EXPRESSION);
+ if (iter->type != NODE_UNARY_EXPRESSION)
+ return -EINVAL;
if (nr_vals == 0)
target = &start;
else
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
uint64_t *target;
- assert(iter->type == NODE_UNARY_EXPRESSION);
+ if (iter->type != NODE_UNARY_EXPRESSION)
+ return -EINVAL;
if (nr_vals == 0)
target = &start;
else
* declaration: ref is only taken upon definition.
*/
if (!has_body) {
- assert(name);
+ if (!name)
+ return NULL;
enum_declaration =
bt_lookup_enum_declaration(g_quark_from_string(name),
declaration_scope);
ret = bt_register_enum_declaration(g_quark_from_string(name),
enum_declaration,
declaration_scope);
- assert(!ret);
+ if (ret)
+ return NULL;
bt_declaration_unref(&enum_declaration->p);
}
return &enum_declaration->p;
str = g_string_new("");
ret = visit_type_specifier_list(fd, type_specifier_list, str);
- if (ret)
+ if (ret) {
+ (void) g_string_free(str, TRUE);
return NULL;
+ }
str_c = g_string_free(str, FALSE);
id_q = g_quark_from_string(str_c);
g_free(str_c);
left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
- assert(left->u.unary_expression.type == UNARY_STRING);
+ if (left->u.unary_expression.type != UNARY_STRING)
+ return NULL;
if (!strcmp(left->u.unary_expression.u.string, "signed")) {
signedness = get_boolean(fd, depth, right);
if (signedness < 0)
left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
- assert(left->u.unary_expression.type == UNARY_STRING);
+ if (left->u.unary_expression.type != UNARY_STRING)
+ return NULL;
if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
byte_order = get_byte_order(fd, depth, right, trace);
if (byte_order < 0)
left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
- assert(left->u.unary_expression.type == UNARY_STRING);
+ if (left->u.unary_expression.type != UNARY_STRING)
+ return NULL;
if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
if (right->u.unary_expression.type != UNARY_STRING) {
fprintf(fd, "[error] %s: encoding: expecting string\n",
struct ctf_node *first;
struct ctf_node *node;
- assert(type_specifier_list->type == NODE_TYPE_SPECIFIER_LIST);
+ if (type_specifier_list->type != NODE_TYPE_SPECIFIER_LIST)
+ return NULL;
first = _bt_list_first_entry(&type_specifier_list->u.type_specifier_list.head, struct ctf_node, siblings);
- assert(first->type == NODE_TYPE_SPECIFIER);
+ if (first->type != NODE_TYPE_SPECIFIER)
+ return NULL;
node = first->u.type_specifier.node;
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "name")) {
char *right;
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "id")) {
if (CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {
fprintf(fd, "[error] %s: id already declared in stream declaration\n", __func__);
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "major")) {
if (CTF_TRACE_FIELD_IS_SET(trace, major)) {
fprintf(fd, "[error] %s: major already declared in trace declaration\n", __func__);
right = _bt_list_first_entry(&node->u.ctf_expression.right, struct ctf_node, siblings);
byte_order = get_trace_byte_order(fd, depth, right);
- if (byte_order < 0)
- return -EINVAL;
+ if (byte_order < 0) {
+ ret = -EINVAL;
+ goto error;
+ }
if (CTF_TRACE_FIELD_IS_SET(trace, byte_order)
&& byte_order != trace->byte_order) {
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "name")) {
char *right;
fprintf(fd, "[error] %s: missing name field in clock declaration\n", __func__);
goto error;
}
- if (g_hash_table_size(trace->clocks) > 0) {
+ if (g_hash_table_size(trace->parent.clocks) > 0) {
fprintf(fd, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
ret = -EINVAL;
goto error;
}
- trace->single_clock = clock;
- g_hash_table_insert(trace->clocks, (gpointer) (unsigned long) clock->name, clock);
+ trace->parent.single_clock = clock;
+ g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
return 0;
error:
clock->absolute = 0; /* Not an absolute reference across traces */
}
- trace->single_clock = clock;
- g_hash_table_insert(trace->clocks, (gpointer) (unsigned long) clock->name, clock);
+ trace->parent.single_clock = clock;
+ g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
}
static
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "name")) {
char *right;
char *left;
left = concatenate_unary_strings(&node->u.ctf_expression.left);
+ if (!left)
+ return -EINVAL;
if (!strcmp(left, "vpid")) {
uint64_t v;
char *right;
right = concatenate_unary_strings(&node->u.ctf_expression.right);
+ if (!right) {
+ fprintf(fd, "[warning] %s: unexpected unary expression for env\n", __func__);
+ ret = -EINVAL;
+ goto error;
+ }
printf_verbose("env.%s = \"%s\"\n", left, right);
g_free(right);
} else if (is_unary_unsigned(&node->u.ctf_expression.right)) {
int ret;
ret = get_unary_unsigned(&node->u.ctf_expression.right, &v);
- assert(ret == 0);
+ if (ret)
+ goto error;
printf_verbose("env.%s = %" PRIu64 "\n", left, v);
} else if (is_unary_signed(&node->u.ctf_expression.right)) {
int64_t v;
int ret;
ret = get_unary_signed(&node->u.ctf_expression.right, &v);
- assert(ret == 0);
+ if (ret)
+ goto error;
printf_verbose("env.%s = %" PRId64 "\n", left, v);
} else {
printf_verbose("%s: attribute \"%s\" has unknown type.\n", __func__, left);
printf_verbose("CTF visitor: metadata construction...\n");
trace->byte_order = byte_order;
- trace->clocks = g_hash_table_new_full(g_direct_hash, g_direct_equal,
- NULL, clock_free);
+ trace->parent.clocks = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL, clock_free);
trace->callsites = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, callsite_free);
error:
bt_free_declaration_scope(trace->root_declaration_scope);
g_hash_table_destroy(trace->callsites);
- g_hash_table_destroy(trace->clocks);
+ g_hash_table_destroy(trace->parent.clocks);
return ret;
}
bt_free_declaration_scope(trace->declaration_scope);
g_hash_table_destroy(trace->callsites);
- g_hash_table_destroy(trace->clocks);
+ g_hash_table_destroy(trace->parent.clocks);
metadata_stream = container_of(trace->metadata, struct ctf_file_stream, parent);
g_free(metadata_stream);
projects / babeltrace.git / blobdiff