g_quark_from_static_string("id"));
if (len_index >= 0) {
struct definition_integer *defint;
- struct field *field;
+ struct definition *field;
field = struct_definition_get_field_from_index(stream_class->event_header, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
- defint = container_of(field->definition, struct definition_integer, p);
+ assert(field->declaration->id == CTF_TYPE_INTEGER);
+ defint = container_of(field, struct definition_integer, p);
assert(defint->declaration->signedness == FALSE);
id = defint->value._unsigned; /* set id */
}
len_index = struct_declaration_lookup_field_index(td->packet_header->declaration, g_quark_from_static_string("magic"));
if (len_index >= 0) {
struct definition_integer *defint;
- struct field *field;
+ struct definition *field;
field = struct_definition_get_field_from_index(td->packet_header, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
- defint = container_of(field->definition, struct definition_integer, p);
+ assert(field->declaration->id == CTF_TYPE_INTEGER);
+ defint = container_of(field, struct definition_integer, p);
assert(defint->declaration->signedness == FALSE);
if (defint->value._unsigned != CTF_MAGIC) {
fprintf(stdout, "[error] Invalid magic number 0x%" PRIX64 " at packet %u (file offset %zd).\n",
len_index = struct_declaration_lookup_field_index(td->packet_header->declaration, g_quark_from_static_string("trace_uuid"));
if (len_index >= 0) {
struct definition_array *defarray;
- struct field *field;
+ struct definition *field;
uint64_t i;
uint8_t uuidval[UUID_LEN];
field = struct_definition_get_field_from_index(td->packet_header, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_ARRAY);
- defarray = container_of(field->definition, struct definition_array, p);
+ assert(field->declaration->id == CTF_TYPE_ARRAY);
+ defarray = container_of(field, struct definition_array, p);
assert(array_len(defarray) == UUID_LEN);
assert(defarray->declaration->elem->id == CTF_TYPE_INTEGER);
len_index = struct_declaration_lookup_field_index(td->packet_header->declaration, g_quark_from_static_string("stream_id"));
if (len_index >= 0) {
struct definition_integer *defint;
- struct field *field;
+ struct definition *field;
field = struct_definition_get_field_from_index(td->packet_header, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
- defint = container_of(field->definition, struct definition_integer, p);
+ assert(field->declaration->id == CTF_TYPE_INTEGER);
+ defint = container_of(field, struct definition_integer, p);
assert(defint->declaration->signedness == FALSE);
stream_id = defint->value._unsigned;
}
len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("content_size"));
if (len_index >= 0) {
struct definition_integer *defint;
- struct field *field;
+ struct definition *field;
field = struct_definition_get_field_from_index(stream->packet_context, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
- defint = container_of(field->definition, struct definition_integer, p);
+ assert(field->declaration->id == CTF_TYPE_INTEGER);
+ defint = container_of(field, struct definition_integer, p);
assert(defint->declaration->signedness == FALSE);
packet_index.content_size = defint->value._unsigned;
} else {
len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("packet_size"));
if (len_index >= 0) {
struct definition_integer *defint;
- struct field *field;
+ struct definition *field;
field = struct_definition_get_field_from_index(stream->packet_context, len_index);
- assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
- defint = container_of(field->definition, struct definition_integer, p);
+ assert(field->declaration->id == CTF_TYPE_INTEGER);
+ defint = container_of(field, struct definition_integer, p);
assert(defint->declaration->signedness == FALSE);
packet_index.packet_size = defint->value._unsigned;
} else {
struct definition {
struct declaration *declaration;
int index; /* Position of the definition in its container */
+ GQuark name; /* Field name in its container (or 0 if unset) */
int ref; /* number of references to the definition */
};
struct declaration *declaration;
};
-struct field {
- GQuark name;
- struct definition *definition;
-};
-
struct declaration_struct {
struct declaration p;
GHashTable *fields_by_name; /* Tuples (field name, field index) */
struct definition p;
struct declaration_struct *declaration;
struct definition_scope *scope;
- GArray *fields; /* Array of struct field */
+ GPtrArray *fields; /* Array of pointers to struct definition */
};
struct declaration_untagged_variant {
struct declaration_variant *declaration;
struct definition_scope *scope;
struct definition *enum_tag;
- GArray *fields; /* Array of struct field */
- struct field *current_field; /* Last field read */
+ GPtrArray *fields; /* Array of pointers to struct definition */
+ struct definition *current_field; /* Last field read */
};
struct declaration_array {
struct definition p;
struct declaration_array *declaration;
struct definition_scope *scope;
- GArray *elems; /* struct field */
+ GPtrArray *elems; /* Array of pointers to struct definition */
};
struct declaration_sequence {
struct declaration_sequence *declaration;
struct definition_scope *scope;
struct definition_integer *len;
- GArray *elems; /* struct field */
+ GPtrArray *elems; /* Array of pointers to struct definition */
};
int register_declaration(GQuark declaration_name,
struct declaration_field *
struct_declaration_get_field_from_index(struct declaration_struct *struct_declaration,
int index);
-struct field *
+struct definition *
struct_definition_get_field_from_index(struct definition_struct *struct_definition,
int index);
int struct_rw(struct stream_pos *pos, struct definition *definition);
* field returned only valid as long as the variant structure is not appended
* to.
*/
-struct field *variant_get_current_field(struct definition_variant *variant);
+struct definition *variant_get_current_field(struct definition_variant *variant);
int variant_rw(struct stream_pos *pos, struct definition *definition);
/*
/* No need to align, because the first field will align itself. */
for (i = 0; i < array_declaration->len; i++) {
- struct definition *elem =
- g_array_index(array_definition->elems, struct field, i).definition;
- ret = generic_rw(pos, elem);
+ struct definition *field =
+ g_ptr_array_index(array_definition->elems, i);
+ ret = generic_rw(pos, field);
if (ret)
return ret;
}
array->declaration = array_declaration;
array->p.ref = 1;
array->p.index = index;
+ array->p.name = field_name;
array->scope = new_definition_scope(parent_scope, field_name);
- array->elems = g_array_sized_new(FALSE, TRUE, sizeof(struct field),
- array_declaration->len);
- g_array_set_size(array->elems, array_declaration->len);
+ array->elems = g_ptr_array_sized_new(array_declaration->len);
+ g_ptr_array_set_size(array->elems, array_declaration->len);
for (i = 0; i < array_declaration->len; i++) {
- struct field *field;
+ struct definition **field;
GString *str;
GQuark name;
name = g_quark_from_string(str->str);
(void) g_string_free(str, TRUE);
- field = &g_array_index(array->elems, struct field, i);
- field->name = name;
- field->definition = array_declaration->elem->definition_new(array_declaration->elem,
+ field = (struct definition **) &g_ptr_array_index(array->elems, i);
+ *field = array_declaration->elem->definition_new(array_declaration->elem,
array->scope,
name, i);
}
uint64_t i;
for (i = 0; i < array->elems->len; i++) {
- struct field *field;
+ struct definition *field;
- field = &g_array_index(array->elems, struct field, i);
- field->definition->declaration->definition_free(field->definition);
+ field = g_ptr_array_index(array->elems, i);
+ field->declaration->definition_free(field);
}
- (void) g_array_free(array->elems, TRUE);
+ (void) g_ptr_array_free(array->elems, TRUE);
free_definition_scope(array->scope);
declaration_unref(array->p.declaration);
g_free(array);
{
if (i >= array->elems->len)
return NULL;
- return g_array_index(array->elems, struct field, i).definition;
+ return g_ptr_array_index(array->elems, i);
}
_enum->declaration = enum_declaration;
_enum->p.ref = 1;
_enum->p.index = index;
+ _enum->p.name = field_name;
_enum->value = NULL;
definition_integer_parent =
enum_declaration->integer_declaration->p.definition_new(&enum_declaration->integer_declaration->p,
- parent_scope, field_name, 0);
+ parent_scope,
+ g_quark_from_static_string("container"), 0);
_enum->integer = container_of(definition_integer_parent,
struct definition_integer, p);
return &_enum->p;
}
_float->p.ref = 1;
_float->p.index = index;
+ _float->p.name = field_name;
_float->value = 0.0;
return &_float->p;
}
integer->declaration = integer_declaration;
integer->p.ref = 1;
integer->p.index = index;
+ integer->p.name = field_name;
integer->value._unsigned = 0;
return &integer->p;
}
*/
oldlen = sequence_definition->elems->len;
if (oldlen < len)
- g_array_set_size(sequence_definition->elems, len);
+ g_ptr_array_set_size(sequence_definition->elems, len);
for (i = oldlen; i < len; i++) {
- struct field *field;
+ struct definition **field;
GString *str;
GQuark name;
(void) g_string_free(str, TRUE);
name = g_quark_from_string(str->str);
- field = &g_array_index(sequence_definition->elems, struct field, i);
- field->name = name;
- field->definition = sequence_declaration->elem->definition_new(sequence_declaration->elem,
+ field = (struct definition **) &g_ptr_array_index(sequence_definition->elems, i);
+ *field = sequence_declaration->elem->definition_new(sequence_declaration->elem,
sequence_definition->scope,
name, i);
- ret = generic_rw(pos, field->definition);
+ ret = generic_rw(pos, *field);
if (ret)
return ret;
}
sequence->declaration = sequence_declaration;
sequence->p.ref = 1;
sequence->p.index = index;
+ sequence->p.name = field_name;
sequence->scope = new_definition_scope(parent_scope, field_name);
len_parent = sequence_declaration->len_declaration->p.definition_new(&sequence_declaration->len_declaration->p,
sequence->scope,
g_quark_from_static_string("length"), 0);
sequence->len =
container_of(len_parent, struct definition_integer, p);
- sequence->elems = g_array_new(FALSE, TRUE, sizeof(struct field));
+ sequence->elems = g_ptr_array_new();
return &sequence->p;
}
uint64_t i;
for (i = 0; i < sequence->elems->len; i++) {
- struct field *field;
+ struct definition *field;
- field = &g_array_index(sequence->elems, struct field, i);
- field->definition->declaration->definition_free(field->definition);
+ field = g_ptr_array_index(sequence->elems, i);
+ field->declaration->definition_free(field);
}
- (void) g_array_free(sequence->elems, TRUE);
+ (void) g_ptr_array_free(sequence->elems, TRUE);
len_definition->declaration->definition_free(len_definition);
free_definition_scope(sequence->scope);
declaration_unref(sequence->p.declaration);
if (i >= sequence->len->value._unsigned)
return NULL;
assert(i < sequence->elems->len);
- return g_array_index(sequence->elems, struct field, i).definition;
+ return g_ptr_array_index(sequence->elems, i);
}
string->declaration = string_declaration;
string->p.ref = 1;
string->p.index = index;
+ string->p.name = field_name;
string->value = NULL;
string->len = 0;
string->alloc_len = 0;
int ret;
for (i = 0; i < struct_definition->fields->len; i++) {
- struct field *field = &g_array_index(struct_definition->fields,
- struct field, i);
- ret = generic_rw(ppos, field->definition);
+ struct definition *field =
+ g_ptr_array_index(struct_definition->fields, i);
+ ret = generic_rw(ppos, field);
if (ret)
return ret;
}
_struct->declaration = struct_declaration;
_struct->p.ref = 1;
_struct->p.index = index;
+ _struct->p.name = field_name;
_struct->scope = new_definition_scope(parent_scope, field_name);
- _struct->fields = g_array_sized_new(FALSE, TRUE,
- sizeof(struct field),
- DEFAULT_NR_STRUCT_FIELDS);
- g_array_set_size(_struct->fields, struct_declaration->fields->len);
+ _struct->fields = g_ptr_array_sized_new(DEFAULT_NR_STRUCT_FIELDS);
+ g_ptr_array_set_size(_struct->fields, struct_declaration->fields->len);
for (i = 0; i < struct_declaration->fields->len; i++) {
struct declaration_field *declaration_field =
&g_array_index(struct_declaration->fields,
struct declaration_field, i);
- struct field *field = &g_array_index(_struct->fields,
- struct field, i);
+ struct definition **field =
+ (struct definition **) &g_ptr_array_index(_struct->fields, i);
- field->name = declaration_field->name;
- field->definition =
- declaration_field->declaration->definition_new(declaration_field->declaration,
+ *field = declaration_field->declaration->definition_new(declaration_field->declaration,
_struct->scope,
- field->name, i);
- ret = register_field_definition(field->name,
- field->definition,
+ declaration_field->name, i);
+ ret = register_field_definition(declaration_field->name,
+ *field,
_struct->scope);
assert(!ret);
}
assert(_struct->fields->len == _struct->declaration->fields->len);
for (i = 0; i < _struct->fields->len; i++) {
- struct field *field = &g_array_index(_struct->fields,
- struct field, i);
- definition_unref(field->definition);
+ struct definition *field = g_ptr_array_index(_struct->fields, i);
+ definition_unref(field);
}
free_definition_scope(_struct->scope);
declaration_unref(_struct->p.declaration);
/*
* field returned only valid as long as the field structure is not appended to.
*/
-struct field *
+struct definition *
struct_definition_get_field_from_index(struct definition_struct *_struct,
int index)
{
if (index < 0)
return NULL;
- return &g_array_index(_struct->fields, struct field, index);
+ return g_ptr_array_index(_struct->fields, index);
}
/*
- * declarations.c
+ * types.c
*
* BabelTrace - Converter
*
{
struct definition_variant *variant_definition =
container_of(definition, struct definition_variant, p);
- struct field *field;
+ struct definition *field;
field = variant_get_current_field(variant_definition);
- return generic_rw(ppos, field->definition);
+ return generic_rw(ppos, field);
}
static
variant->declaration = variant_declaration;
variant->p.ref = 1;
variant->p.index = index;
+ variant->p.name = field_name;
variant->scope = new_definition_scope(parent_scope, field_name);
variant->enum_tag = lookup_definition(variant->scope->scope_path,
variant_declaration->tag_name,
|| check_enum_tag(variant, variant->enum_tag) < 0)
goto error;
definition_ref(variant->enum_tag);
- variant->fields = g_array_sized_new(FALSE, TRUE,
- sizeof(struct field),
- variant_declaration->untagged_variant->fields->len);
- g_array_set_size(variant->fields, variant_declaration->untagged_variant->fields->len);
+ variant->fields = g_ptr_array_sized_new(variant_declaration->untagged_variant->fields->len);
+ g_ptr_array_set_size(variant->fields, variant_declaration->untagged_variant->fields->len);
for (i = 0; i < variant_declaration->untagged_variant->fields->len; i++) {
struct declaration_field *declaration_field =
&g_array_index(variant_declaration->untagged_variant->fields,
struct declaration_field, i);
- struct field *field = &g_array_index(variant->fields,
- struct field, i);
+ struct definition **field =
+ (struct definition **) &g_ptr_array_index(variant->fields, i);
- field->name = declaration_field->name;
/*
* All child definition are at index 0, because they are
* various choices of the same field.
*/
- field->definition =
- declaration_field->declaration->definition_new(declaration_field->declaration,
- variant->scope,
- field->name, 0);
+ *field = declaration_field->declaration->definition_new(declaration_field->declaration,
+ variant->scope,
+ declaration_field->name, 0);
}
variant->current_field = NULL;
return &variant->p;
assert(variant->fields->len == variant->declaration->untagged_variant->fields->len);
for (i = 0; i < variant->fields->len; i++) {
- struct field *field = &g_array_index(variant->fields,
- struct field, i);
- definition_unref(field->definition);
+ struct definition *field = g_ptr_array_index(variant->fields, i);
+ definition_unref(field);
}
definition_unref(variant->enum_tag);
free_definition_scope(variant->scope);
/*
* field returned only valid as long as the field structure is not appended to.
*/
-struct field *variant_get_current_field(struct definition_variant *variant)
+struct definition *variant_get_current_field(struct definition_variant *variant)
{
struct definition_enum *_enum =
container_of(variant->enum_tag, struct definition_enum, p);
tag = g_array_index(tag_array, GQuark, 0);
index = (unsigned long) g_hash_table_lookup(variant_declaration->untagged_variant->fields_by_tag,
(gconstpointer) (unsigned long) tag);
- variant->current_field = &g_array_index(variant->fields, struct field, index);
+ variant->current_field = g_ptr_array_index(variant->fields, index);
return variant->current_field;
}