[babeltrace.git] / types / struct.c

/*
 * struct.c
 *
 * BabelTrace - Structure Type Converter
 *
 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

#include <babeltrace/compiler.h>
#include <babeltrace/format.h>

#ifndef max
#define max(a, b)	((a) < (b) ? (b) : (a))
#endif

static
struct definition *_struct_definition_new(struct declaration *declaration,
				struct definition_scope *parent_scope,
				GQuark field_name, int index);
static
void _struct_definition_free(struct definition *definition);

int struct_rw(struct stream_pos *ppos, struct definition *definition)
{
	struct definition_struct *struct_definition =
		container_of(definition, struct definition_struct, p);
	unsigned long i;
	int ret;

	for (i = 0; i < struct_definition->fields->len; i++) {
		struct definition *field =
			g_ptr_array_index(struct_definition->fields, i);
		ret = generic_rw(ppos, field);
		if (ret)
			return ret;
	}
	return 0;
}

static
void _struct_declaration_free(struct declaration *declaration)
{
	struct declaration_struct *struct_declaration =
		container_of(declaration, struct declaration_struct, p);
	unsigned long i;

	free_declaration_scope(struct_declaration->scope);
	g_hash_table_destroy(struct_declaration->fields_by_name);

	for (i = 0; i < struct_declaration->fields->len; i++) {
		struct declaration_field *declaration_field =
			&g_array_index(struct_declaration->fields,
				       struct declaration_field, i);
		declaration_unref(declaration_field->declaration);
	}
	g_array_free(struct_declaration->fields, true);
	g_free(struct_declaration);
}

struct declaration_struct *
	struct_declaration_new(struct declaration_scope *parent_scope,
			       uint64_t min_align)
{
	struct declaration_struct *struct_declaration;
	struct declaration *declaration;

	struct_declaration = g_new(struct declaration_struct, 1);
	declaration = &struct_declaration->p;
	struct_declaration->fields_by_name = g_hash_table_new(g_direct_hash,
						       g_direct_equal);
	struct_declaration->fields = g_array_sized_new(FALSE, TRUE,
						sizeof(struct declaration_field),
						DEFAULT_NR_STRUCT_FIELDS);
	struct_declaration->scope = new_declaration_scope(parent_scope);
	declaration->id = CTF_TYPE_STRUCT;
	declaration->alignment = max(1, min_align);
	declaration->declaration_free = _struct_declaration_free;
	declaration->definition_new = _struct_definition_new;
	declaration->definition_free = _struct_definition_free;
	declaration->ref = 1;
	return struct_declaration;
}

static
struct definition *
	_struct_definition_new(struct declaration *declaration,
			       struct definition_scope *parent_scope,
			       GQuark field_name, int index)
{
	struct declaration_struct *struct_declaration =
		container_of(declaration, struct declaration_struct, p);
	struct definition_struct *_struct;
	unsigned long i;
	int ret;

	_struct = g_new(struct definition_struct, 1);
	declaration_ref(&struct_declaration->p);
	_struct->p.declaration = declaration;
	_struct->declaration = struct_declaration;
	_struct->p.ref = 1;
	_struct->p.index = index;
	_struct->p.name = field_name;
	_struct->p.path = new_definition_path(parent_scope, field_name);
	_struct->scope = new_definition_scope(parent_scope, field_name);
	_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 definition **field =
			(struct definition **) &g_ptr_array_index(_struct->fields, i);

		*field = declaration_field->declaration->definition_new(declaration_field->declaration,
							  _struct->scope,
							  declaration_field->name, i);
		ret = register_field_definition(declaration_field->name,
						*field,
						_struct->scope);
		assert(!ret);
	}
	return &_struct->p;
}

static
void _struct_definition_free(struct definition *definition)
{
	struct definition_struct *_struct =
		container_of(definition, struct definition_struct, p);
	unsigned long i;

	assert(_struct->fields->len == _struct->declaration->fields->len);
	for (i = 0; i < _struct->fields->len; i++) {
		struct definition *field = g_ptr_array_index(_struct->fields, i);
		definition_unref(field);
	}
	free_definition_scope(_struct->scope);
	declaration_unref(_struct->p.declaration);
	g_free(_struct);
}

void struct_declaration_add_field(struct declaration_struct *struct_declaration,
			   const char *field_name,
			   struct declaration *field_declaration)
{
	struct declaration_field *field;
	unsigned long index;

	g_array_set_size(struct_declaration->fields, struct_declaration->fields->len + 1);
	index = struct_declaration->fields->len - 1;	/* last field (new) */
	field = &g_array_index(struct_declaration->fields, struct declaration_field, index);
	field->name = g_quark_from_string(field_name);
	declaration_ref(field_declaration);
	field->declaration = field_declaration;
	/* Keep index in hash rather than pointer, because array can relocate */
	g_hash_table_insert(struct_declaration->fields_by_name,
			    (gpointer) (unsigned long) field->name,
			    (gpointer) index);
	/*
	 * Alignment of structure is the max alignment of declarations contained
	 * therein.
	 */
	struct_declaration->p.alignment = max(struct_declaration->p.alignment,
				       field_declaration->alignment);
}

/*
 * struct_declaration_lookup_field_index - returns field index
 *
 * Returns the index of a field in a structure, or -1 if it does not
 * exist.
 */
int struct_declaration_lookup_field_index(struct declaration_struct *struct_declaration,
				       GQuark field_name)
{
	gpointer index;
	gboolean found;

	found = g_hash_table_lookup_extended(struct_declaration->fields_by_name,
				    (gconstpointer) (unsigned long) field_name,
				    NULL, &index);
	if (!found)
		return -1;
	return (int) (unsigned long) index;
}

/*
 * field returned only valid as long as the field structure is not appended to.
 */
struct declaration_field *
	struct_declaration_get_field_from_index(struct declaration_struct *struct_declaration,
					 int index)
{
	if (index < 0)
		return NULL;
	return &g_array_index(struct_declaration->fields, struct declaration_field, index);
}

/*
 * field returned only valid as long as the field structure is not appended to.
 */
struct definition *
struct_definition_get_field_from_index(struct definition_struct *_struct,
					int index)
{
	if (index < 0)
		return NULL;
	return g_ptr_array_index(_struct->fields, index);
}

uint64_t struct_declaration_len(struct declaration_struct *struct_declaration)
{
	return struct_declaration->fields->len;
}
Commit	Line	Data
	1	/*
	2	* struct.c
	3	*
	4	* BabelTrace - Structure Type Converter
	5	*
	6	* Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*/
	18
	19	#include <babeltrace/compiler.h>
	20	#include <babeltrace/format.h>
	21
	22	#ifndef max
	23	#define max(a, b) ((a) < (b) ? (b) : (a))
	24	#endif
	25
	26	static
	27	struct definition _struct_definition_new(struct declaration declaration,
	28	struct definition_scope *parent_scope,
	29	GQuark field_name, int index);
	30	static
	31	void _struct_definition_free(struct definition *definition);
	32
	33	int struct_rw(struct stream_pos ppos, struct definition definition)
	34	{
	35	struct definition_struct *struct_definition =
	36	container_of(definition, struct definition_struct, p);
	37	unsigned long i;
	38	int ret;
	39
	40	for (i = 0; i < struct_definition->fields->len; i++) {
	41	struct definition *field =
	42	g_ptr_array_index(struct_definition->fields, i);
	43	ret = generic_rw(ppos, field);
	44	if (ret)
	45	return ret;
	46	}
	47	return 0;
	48	}
	49
	50	static
	51	void _struct_declaration_free(struct declaration *declaration)
	52	{
	53	struct declaration_struct *struct_declaration =
	54	container_of(declaration, struct declaration_struct, p);
	55	unsigned long i;
	56
	57	free_declaration_scope(struct_declaration->scope);
	58	g_hash_table_destroy(struct_declaration->fields_by_name);
	59
	60	for (i = 0; i < struct_declaration->fields->len; i++) {
	61	struct declaration_field *declaration_field =
	62	&g_array_index(struct_declaration->fields,
	63	struct declaration_field, i);
	64	declaration_unref(declaration_field->declaration);
	65	}
	66	g_array_free(struct_declaration->fields, true);
	67	g_free(struct_declaration);
	68	}
	69
	70	struct declaration_struct *
	71	struct_declaration_new(struct declaration_scope *parent_scope,
	72	uint64_t min_align)
	73	{
	74	struct declaration_struct *struct_declaration;
	75	struct declaration *declaration;
	76
	77	struct_declaration = g_new(struct declaration_struct, 1);
	78	declaration = &struct_declaration->p;
	79	struct_declaration->fields_by_name = g_hash_table_new(g_direct_hash,
	80	g_direct_equal);
	81	struct_declaration->fields = g_array_sized_new(FALSE, TRUE,
	82	sizeof(struct declaration_field),
	83	DEFAULT_NR_STRUCT_FIELDS);
	84	struct_declaration->scope = new_declaration_scope(parent_scope);
	85	declaration->id = CTF_TYPE_STRUCT;
	86	declaration->alignment = max(1, min_align);
	87	declaration->declaration_free = _struct_declaration_free;
	88	declaration->definition_new = _struct_definition_new;
	89	declaration->definition_free = _struct_definition_free;
	90	declaration->ref = 1;
	91	return struct_declaration;
	92	}
	93
	94	static
	95	struct definition *
	96	_struct_definition_new(struct declaration *declaration,
	97	struct definition_scope *parent_scope,
	98	GQuark field_name, int index)
	99	{
	100	struct declaration_struct *struct_declaration =
	101	container_of(declaration, struct declaration_struct, p);
	102	struct definition_struct *_struct;
	103	unsigned long i;
	104	int ret;
	105
	106	_struct = g_new(struct definition_struct, 1);
	107	declaration_ref(&struct_declaration->p);
	108	_struct->p.declaration = declaration;
	109	_struct->declaration = struct_declaration;
	110	_struct->p.ref = 1;
	111	_struct->p.index = index;
	112	_struct->p.name = field_name;
	113	_struct->p.path = new_definition_path(parent_scope, field_name);
	114	_struct->scope = new_definition_scope(parent_scope, field_name);
	115	_struct->fields = g_ptr_array_sized_new(DEFAULT_NR_STRUCT_FIELDS);
	116	g_ptr_array_set_size(_struct->fields, struct_declaration->fields->len);
	117	for (i = 0; i < struct_declaration->fields->len; i++) {
	118	struct declaration_field *declaration_field =
	119	&g_array_index(struct_declaration->fields,
	120	struct declaration_field, i);
	121	struct definition **field =
	122	(struct definition **) &g_ptr_array_index(_struct->fields, i);
	123
	124	*field = declaration_field->declaration->definition_new(declaration_field->declaration,
	125	_struct->scope,
	126	declaration_field->name, i);
	127	ret = register_field_definition(declaration_field->name,
	128	*field,
	129	_struct->scope);
	130	assert(!ret);
	131	}
	132	return &_struct->p;
	133	}
	134
	135	static
	136	void _struct_definition_free(struct definition *definition)
	137	{
	138	struct definition_struct *_struct =
	139	container_of(definition, struct definition_struct, p);
	140	unsigned long i;
	141
	142	assert(_struct->fields->len == _struct->declaration->fields->len);
	143	for (i = 0; i < _struct->fields->len; i++) {
	144	struct definition *field = g_ptr_array_index(_struct->fields, i);
	145	definition_unref(field);
	146	}
	147	free_definition_scope(_struct->scope);
	148	declaration_unref(_struct->p.declaration);
	149	g_free(_struct);
	150	}
	151
	152	void struct_declaration_add_field(struct declaration_struct *struct_declaration,
	153	const char *field_name,
	154	struct declaration *field_declaration)
	155	{
	156	struct declaration_field *field;
	157	unsigned long index;
	158
	159	g_array_set_size(struct_declaration->fields, struct_declaration->fields->len + 1);
	160	index = struct_declaration->fields->len - 1; /* last field (new) */
	161	field = &g_array_index(struct_declaration->fields, struct declaration_field, index);
	162	field->name = g_quark_from_string(field_name);
	163	declaration_ref(field_declaration);
	164	field->declaration = field_declaration;
	165	/* Keep index in hash rather than pointer, because array can relocate */
	166	g_hash_table_insert(struct_declaration->fields_by_name,
	167	(gpointer) (unsigned long) field->name,
	168	(gpointer) index);
	169	/*
	170	* Alignment of structure is the max alignment of declarations contained
	171	* therein.
	172	*/
	173	struct_declaration->p.alignment = max(struct_declaration->p.alignment,
	174	field_declaration->alignment);
	175	}
	176
	177	/*
	178	* struct_declaration_lookup_field_index - returns field index
	179	*
	180	* Returns the index of a field in a structure, or -1 if it does not
	181	* exist.
	182	*/
	183	int struct_declaration_lookup_field_index(struct declaration_struct *struct_declaration,
	184	GQuark field_name)
	185	{
	186	gpointer index;
	187	gboolean found;
	188
	189	found = g_hash_table_lookup_extended(struct_declaration->fields_by_name,
	190	(gconstpointer) (unsigned long) field_name,
	191	NULL, &index);
	192	if (!found)
	193	return -1;
	194	return (int) (unsigned long) index;
	195	}
	196
	197	/*
	198	* field returned only valid as long as the field structure is not appended to.
	199	*/
	200	struct declaration_field *
	201	struct_declaration_get_field_from_index(struct declaration_struct *struct_declaration,
	202	int index)
	203	{
	204	if (index < 0)
	205	return NULL;
	206	return &g_array_index(struct_declaration->fields, struct declaration_field, index);
	207	}
	208
	209	/*
	210	* field returned only valid as long as the field structure is not appended to.
	211	*/
	212	struct definition *
	213	struct_definition_get_field_from_index(struct definition_struct *_struct,
	214	int index)
	215	{
	216	if (index < 0)
	217	return NULL;
	218	return g_ptr_array_index(_struct->fields, index);
	219	}
	220
	221	uint64_t struct_declaration_len(struct declaration_struct *struct_declaration)
	222	{
	223	return struct_declaration->fields->len;
	224	}