[babeltrace.git] / types / types.c

/*
 * declarations.c
 *
 * BabelTrace - Converter
 *
 * Types registry.
 *
 * 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/format.h>
#include <glib.h>
#include <errno.h>

static
struct definition *
	lookup_typedef_declaration_scope(GQuark declaration_name,
		struct declaration_scope *scope)
{
	return g_hash_table_lookup(scope->typedef_declarations,
				   (gconstpointer) (unsigned long) declaration_name);
}

struct definition *lookup_typedef_declaration(GQuark declaration_name,
		struct declaration_scope *scope)
{
	struct definition *definition;

	while (scope) {
		definition = lookup_typedef_declaration_scope(declaration_name,
							      scope);
		if (definition)
			return definition;
		scope = scope->parent_scope;
	}
	return NULL;
}

int register_typedef_declaration(GQuark name, struct declaration *declaration,
		struct declaration_scope *scope)
{
	if (!name)
		return -EPERM;

	/* Only lookup in local scope */
	if (lookup_typedef_declaration_scope(name, scope))
		return -EEXIST;

	g_hash_table_insert(scope->typedef_declarations,
			    (gpointer) (unsigned long) name,
			    declaration);
	declaration_ref(declaration);
	return 0;
}

static
struct definition *
	lookup_field_definition_scope(GQuark field_name,
		struct definition_scope *scope)
{
	return g_hash_table_lookup(scope->definitions,
				   (gconstpointer) (unsigned long) field_name);
}

/*
 * Returns the index at which the paths differ.
 * If the value returned equals len, it means the paths are identical
 * from index 0 to len-1.
 */
static int compare_paths(GArray *a, GArray *b, int len)
{
	int i;

	assert(len <= a->len);
	assert(len <= b->len);

	for (i = 0; i < len; i++) {
		GQuark qa, qb;

		qa = g_array_index(a, GQuark, i);
		qb = g_array_index(b, GQuark, i);
		if (qa != qb)
			return i;
	}
	return i;
}

static int is_path_child_of(GArray *path, GArray *maybe_parent)
{
	if (path->len <= maybe_parent->len)
		return 0;
	if (compare_paths(path, maybe_parent, maybe_parent->len)
			== maybe_parent->len)
		return 1;
	else
		return 0;
}

static struct definition_scope *
	get_definition_scope(struct definition *definition)
{
	switch (definition->declaration->id) {
	case CTF_TYPE_STRUCT:
	{
		struct definition_struct *def =
			container_of(definition, struct definition_struct, p);
		return def->scope;
	}
	case CTF_TYPE_VARIANT:
	{
		struct definition_variant *def =
			container_of(definition, struct definition_variant, p);
		return def->scope;
	}
	case CTF_TYPE_ARRAY:
	{
		struct definition_array *def =
			container_of(definition, struct definition_array, p);
		return def->scope;
	}
	case CTF_TYPE_SEQUENCE:
	{
		struct definition_sequence *def =
			container_of(definition, struct definition_sequence, p);
		return def->scope;
	}

	case CTF_TYPE_INTEGER:
	case CTF_TYPE_FLOAT:
	case CTF_TYPE_ENUM:
	case CTF_TYPE_STRING:
	case CTF_TYPE_UNKNOWN:
	default:
		return NULL;
	}
}

/*
 * OK, here is the fun. We want to lookup a field that is:
 * - either in the same dynamic scope:
 *   - either in the current scope, but prior to the current field.
 *   - or in a parent scope (or parent of parent ...) still in a field
 *     prior to the current field position within the parents.
 * - or in a different dynamic scope:
 *   - either in a upper dynamic scope (walk down a targeted scope from
 *     the dynamic scope root)
 *   - or in a lower dynamic scope (failure)
 * The dynamic scope roots are linked together, so we can access the
 * parent dynamic scope from the child dynamic scope by walking up to
 * the parent.
 * If we cannot find such a field that is prior to our current path, we
 * return NULL.
 *
 * cur_path: the path leading to the variant definition.
 * lookup_path: the path leading to the enum we want to look for.
 * scope: the definition scope containing the variant definition.
 */
struct definition *
	lookup_definition(GArray *cur_path,
			  GArray *lookup_path,
			  struct definition_scope *scope)
{
	struct definition *definition, *lookup_definition;
	GQuark last;
	int index;

	while (scope) {
		/* going up in the hierarchy. Check where we come from. */
		assert(is_path_child_of(cur_path, scope->scope_path));
		assert(cur_path->len - scope->scope_path->len == 1);
		last = g_array_index(cur_path, GQuark, cur_path->len - 1);
		definition = lookup_field_definition_scope(last, scope);
		assert(definition);
		index = definition->index;
lookup:
		if (is_path_child_of(lookup_path, scope->scope_path)) {
			/* Means we can lookup the field in this scope */
			last = g_array_index(lookup_path, GQuark,
					     scope->scope_path->len);
			lookup_definition = lookup_field_definition_scope(last, scope);
			if (!lookup_definition || ((index != -1) && lookup_definition->index >= index))
				return NULL;
			/* Found it! And it is prior to the current field. */
			if (lookup_path->len - scope->scope_path->len == 1) {
				/* Direct child */
				return lookup_definition;
			} else {
				scope = get_definition_scope(lookup_definition);
				/* Check if the definition has a sub-scope */
				if (!scope)
					return NULL;
				/*
				 * Don't compare index anymore, because we are
				 * going within a scope that has been validated
				 * to be entirely prior to the current scope.
				 */
				cur_path = NULL;
				index = -1;
				goto lookup;
			}
		} else {
			assert(index != -1);
			/* lookup_path is within an upper scope */
			cur_path = scope->scope_path;
			scope = scope->parent_scope;
		}
	}
	return NULL;
}

int register_field_definition(GQuark field_name, struct definition *definition,
		struct definition_scope *scope)
{
	if (!field_name)
		return -EPERM;

	/* Only lookup in local scope */
	if (lookup_field_definition_scope(field_name, scope))
		return -EEXIST;

	g_hash_table_insert(scope->definitions,
			    (gpointer) (unsigned long) field_name,
			    definition);
	definition_ref(definition);
	return 0;
}

void declaration_ref(struct declaration *declaration)
{
	declaration->ref++;
}

void declaration_unref(struct declaration *declaration)
{
	if (!--declaration->ref)
		declaration->declaration_free(declaration);
}

void definition_ref(struct definition *definition)
{
	definition->ref++;
}

void definition_unref(struct definition *definition)
{
	if (!--definition->ref)
		definition->declaration->definition_free(definition);
}

struct declaration_scope *
	new_declaration_scope(struct declaration_scope *parent_scope)
{
	struct declaration_scope *scope = g_new(struct declaration_scope, 1);

	scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
					g_direct_equal, NULL,
					(GDestroyNotify) definition_unref);
	scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
					g_direct_equal, NULL,
					(GDestroyNotify) declaration_unref);
	scope->variant_declarations = g_hash_table_new_full(g_direct_hash,
					g_direct_equal, NULL,
					(GDestroyNotify) declaration_unref);
	scope->enum_declarations = g_hash_table_new_full(g_direct_hash,
					g_direct_equal, NULL,
					(GDestroyNotify) declaration_unref);
	scope->parent_scope = parent_scope;
	return scope;
}

void free_declaration_scope(struct declaration_scope *scope)
{
	g_hash_table_destroy(scope->enum_declarations);
	g_hash_table_destroy(scope->variant_declarations);
	g_hash_table_destroy(scope->struct_declarations);
	g_hash_table_destroy(scope->typedef_declarations);
	g_free(scope);
}

static
struct declaration_struct *lookup_struct_declaration_scope(GQuark struct_name,
					     struct declaration_scope *scope)
{
	return g_hash_table_lookup(scope->struct_declarations,
				   (gconstpointer) (unsigned long) struct_name);
}

struct declaration_struct *lookup_struct_declaration(GQuark struct_name,
				       struct declaration_scope *scope)
{
	struct declaration_struct *declaration;

	while (scope) {
		declaration = lookup_struct_declaration_scope(struct_name, scope);
		if (declaration)
			return declaration;
		scope = scope->parent_scope;
	}
	return NULL;
}

int register_struct_declaration(GQuark struct_name,
	struct declaration_struct *struct_declaration,
	struct declaration_scope *scope)
{
	if (!struct_name)
		return -EPERM;

	/* Only lookup in local scope */
	if (lookup_struct_declaration_scope(struct_name, scope))
		return -EEXIST;

	g_hash_table_insert(scope->struct_declarations,
			    (gpointer) (unsigned long) struct_name,
			    struct_declaration);
	declaration_ref(&struct_declaration->p);
	return 0;
}

static
struct declaration_variant *
	lookup_variant_declaration_scope(GQuark variant_name,
		struct declaration_scope *scope)
{
	return g_hash_table_lookup(scope->variant_declarations,
				   (gconstpointer) (unsigned long) variant_name);
}

struct declaration_variant *
	lookup_variant_declaration(GQuark variant_name,
		struct declaration_scope *scope)
{
	struct declaration_variant *declaration;

	while (scope) {
		declaration = lookup_variant_declaration_scope(variant_name, scope);
		if (declaration)
			return declaration;
		scope = scope->parent_scope;
	}
	return NULL;
}

int register_variant_declaration(GQuark variant_name,
		struct declaration_variant *variant_declaration,
		struct declaration_scope *scope)
{
	if (!variant_name)
		return -EPERM;

	/* Only lookup in local scope */
	if (lookup_variant_declaration_scope(variant_name, scope))
		return -EEXIST;

	g_hash_table_insert(scope->variant_declarations,
			    (gpointer) (unsigned long) variant_name,
			    variant_declaration);
	declaration_ref(&variant_declaration->p);
	return 0;
}

static
struct declaration_enum *
	lookup_enum_declaration_scope(GQuark enum_name,
		struct declaration_scope *scope)
{
	return g_hash_table_lookup(scope->enum_declarations,
				   (gconstpointer) (unsigned long) enum_name);
}

struct declaration_enum *
	lookup_enum_declaration(GQuark enum_name,
		struct declaration_scope *scope)
{
	struct declaration_enum *declaration;

	while (scope) {
		declaration = lookup_enum_declaration_scope(enum_name, scope);
		if (declaration)
			return declaration;
		scope = scope->parent_scope;
	}
	return NULL;
}

int register_enum_declaration(GQuark enum_name,
		struct declaration_enum *enum_declaration,
		struct declaration_scope *scope)
{
	if (!enum_name)
		return -EPERM;

	/* Only lookup in local scope */
	if (lookup_enum_declaration_scope(enum_name, scope))
		return -EEXIST;

	g_hash_table_insert(scope->enum_declarations,
			    (gpointer) (unsigned long) enum_name,
			    enum_declaration);
	declaration_ref(&enum_declaration->p);
	return 0;
}

static struct definition_scope *
	_new_definition_scope(struct definition_scope *parent_scope,
			      int scope_path_len)
{
	struct definition_scope *scope = g_new(struct definition_scope, 1);

	scope->definitions = g_hash_table_new_full(g_direct_hash,
					g_direct_equal, NULL,
					(GDestroyNotify) definition_unref);
	scope->parent_scope = parent_scope;
	scope->scope_path = g_array_sized_new(FALSE, TRUE, sizeof(GQuark),
					      scope_path_len);
	g_array_set_size(scope->scope_path, scope_path_len);
	return scope;
}

struct definition_scope *
	new_definition_scope(struct definition_scope *parent_scope,
			     GQuark field_name)
{
	struct definition_scope *scope;
	int scope_path_len = 1;

	if (parent_scope)
		scope_path_len += parent_scope->scope_path->len;
	scope = _new_definition_scope(parent_scope, scope_path_len);
	if (parent_scope)
		memcpy(scope->scope_path, parent_scope->scope_path,
		       sizeof(GQuark) * (scope_path_len - 1));
	g_array_index(scope->scope_path, GQuark, scope_path_len - 1) =
		field_name;
	return scope;
}

void set_dynamic_definition_scope(struct definition_scope *scope,
				  GQuark root_name)
{
	g_array_set_size(scope->scope_path, 1);
	g_array_index(scope->scope_path, GQuark, 0) = root_name;
}

void free_definition_scope(struct definition_scope *scope)
{
	g_array_free(scope->scope_path, TRUE);
	g_hash_table_destroy(scope->definitions);
	g_free(scope);
}
Commit	Line	Data
	1	/*
	2	* declarations.c
	3	*
	4	* BabelTrace - Converter
	5	*
	6	* Types registry.
	7	*
	8	* Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*/
	20
	21	#include <babeltrace/format.h>
	22	#include <glib.h>
	23	#include <errno.h>
	24
	25	static
	26	struct definition *
	27	lookup_typedef_declaration_scope(GQuark declaration_name,
	28	struct declaration_scope *scope)
	29	{
	30	return g_hash_table_lookup(scope->typedef_declarations,
	31	(gconstpointer) (unsigned long) declaration_name);
	32	}
	33
	34	struct definition *lookup_typedef_declaration(GQuark declaration_name,
	35	struct declaration_scope *scope)
	36	{
	37	struct definition *definition;
	38
	39	while (scope) {
	40	definition = lookup_typedef_declaration_scope(declaration_name,
	41	scope);
	42	if (definition)
	43	return definition;
	44	scope = scope->parent_scope;
	45	}
	46	return NULL;
	47	}
	48
	49	int register_typedef_declaration(GQuark name, struct declaration *declaration,
	50	struct declaration_scope *scope)
	51	{
	52	if (!name)
	53	return -EPERM;
	54
	55	/* Only lookup in local scope */
	56	if (lookup_typedef_declaration_scope(name, scope))
	57	return -EEXIST;
	58
	59	g_hash_table_insert(scope->typedef_declarations,
	60	(gpointer) (unsigned long) name,
	61	declaration);
	62	declaration_ref(declaration);
	63	return 0;
	64	}
	65
	66	static
	67	struct definition *
	68	lookup_field_definition_scope(GQuark field_name,
	69	struct definition_scope *scope)
	70	{
	71	return g_hash_table_lookup(scope->definitions,
	72	(gconstpointer) (unsigned long) field_name);
	73	}
	74
	75	/*
	76	* Returns the index at which the paths differ.
	77	* If the value returned equals len, it means the paths are identical
	78	* from index 0 to len-1.
	79	*/
	80	static int compare_paths(GArray a, GArray b, int len)
	81	{
	82	int i;
	83
	84	assert(len <= a->len);
	85	assert(len <= b->len);
	86
	87	for (i = 0; i < len; i++) {
	88	GQuark qa, qb;
	89
	90	qa = g_array_index(a, GQuark, i);
	91	qb = g_array_index(b, GQuark, i);
	92	if (qa != qb)
	93	return i;
	94	}
	95	return i;
	96	}
	97
	98	static int is_path_child_of(GArray path, GArray maybe_parent)
	99	{
	100	if (path->len <= maybe_parent->len)
	101	return 0;
	102	if (compare_paths(path, maybe_parent, maybe_parent->len)
	103	== maybe_parent->len)
	104	return 1;
	105	else
	106	return 0;
	107	}
	108
	109	static struct definition_scope *
	110	get_definition_scope(struct definition *definition)
	111	{
	112	switch (definition->declaration->id) {
	113	case CTF_TYPE_STRUCT:
	114	{
	115	struct definition_struct *def =
	116	container_of(definition, struct definition_struct, p);
	117	return def->scope;
	118	}
	119	case CTF_TYPE_VARIANT:
	120	{
	121	struct definition_variant *def =
	122	container_of(definition, struct definition_variant, p);
	123	return def->scope;
	124	}
	125	case CTF_TYPE_ARRAY:
	126	{
	127	struct definition_array *def =
	128	container_of(definition, struct definition_array, p);
	129	return def->scope;
	130	}
	131	case CTF_TYPE_SEQUENCE:
	132	{
	133	struct definition_sequence *def =
	134	container_of(definition, struct definition_sequence, p);
	135	return def->scope;
	136	}
	137
	138	case CTF_TYPE_INTEGER:
	139	case CTF_TYPE_FLOAT:
	140	case CTF_TYPE_ENUM:
	141	case CTF_TYPE_STRING:
	142	case CTF_TYPE_UNKNOWN:
	143	default:
	144	return NULL;
	145	}
	146	}
	147
	148	/*
	149	* OK, here is the fun. We want to lookup a field that is:
	150	* - either in the same dynamic scope:
	151	* - either in the current scope, but prior to the current field.
	152	* - or in a parent scope (or parent of parent ...) still in a field
	153	* prior to the current field position within the parents.
	154	* - or in a different dynamic scope:
	155	* - either in a upper dynamic scope (walk down a targeted scope from
	156	* the dynamic scope root)
	157	* - or in a lower dynamic scope (failure)
	158	* The dynamic scope roots are linked together, so we can access the
	159	* parent dynamic scope from the child dynamic scope by walking up to
	160	* the parent.
	161	* If we cannot find such a field that is prior to our current path, we
	162	* return NULL.
	163	*
	164	* cur_path: the path leading to the variant definition.
	165	* lookup_path: the path leading to the enum we want to look for.
	166	* scope: the definition scope containing the variant definition.
	167	*/
	168	struct definition *
	169	lookup_definition(GArray *cur_path,
	170	GArray *lookup_path,
	171	struct definition_scope *scope)
	172	{
	173	struct definition definition, lookup_definition;
	174	GQuark last;
	175	int index;
	176
	177	while (scope) {
	178	/* going up in the hierarchy. Check where we come from. */
	179	assert(is_path_child_of(cur_path, scope->scope_path));
	180	assert(cur_path->len - scope->scope_path->len == 1);
	181	last = g_array_index(cur_path, GQuark, cur_path->len - 1);
	182	definition = lookup_field_definition_scope(last, scope);
	183	assert(definition);
	184	index = definition->index;
	185	lookup:
	186	if (is_path_child_of(lookup_path, scope->scope_path)) {
	187	/* Means we can lookup the field in this scope */
	188	last = g_array_index(lookup_path, GQuark,
	189	scope->scope_path->len);
	190	lookup_definition = lookup_field_definition_scope(last, scope);
	191	if (!lookup_definition \|\| ((index != -1) && lookup_definition->index >= index))
	192	return NULL;
	193	/* Found it! And it is prior to the current field. */
	194	if (lookup_path->len - scope->scope_path->len == 1) {
	195	/* Direct child */
	196	return lookup_definition;
	197	} else {
	198	scope = get_definition_scope(lookup_definition);
	199	/* Check if the definition has a sub-scope */
	200	if (!scope)
	201	return NULL;
	202	/*
	203	* Don't compare index anymore, because we are
	204	* going within a scope that has been validated
	205	* to be entirely prior to the current scope.
	206	*/
	207	cur_path = NULL;
	208	index = -1;
	209	goto lookup;
	210	}
	211	} else {
	212	assert(index != -1);
	213	/* lookup_path is within an upper scope */
	214	cur_path = scope->scope_path;
	215	scope = scope->parent_scope;
	216	}
	217	}
	218	return NULL;
	219	}
	220
	221	int register_field_definition(GQuark field_name, struct definition *definition,
	222	struct definition_scope *scope)
	223	{
	224	if (!field_name)
	225	return -EPERM;
	226
	227	/* Only lookup in local scope */
	228	if (lookup_field_definition_scope(field_name, scope))
	229	return -EEXIST;
	230
	231	g_hash_table_insert(scope->definitions,
	232	(gpointer) (unsigned long) field_name,
	233	definition);
	234	definition_ref(definition);
	235	return 0;
	236	}
	237
	238	void declaration_ref(struct declaration *declaration)
	239	{
	240	declaration->ref++;
	241	}
	242
	243	void declaration_unref(struct declaration *declaration)
	244	{
	245	if (!--declaration->ref)
	246	declaration->declaration_free(declaration);
	247	}
	248
	249	void definition_ref(struct definition *definition)
	250	{
	251	definition->ref++;
	252	}
	253
	254	void definition_unref(struct definition *definition)
	255	{
	256	if (!--definition->ref)
	257	definition->declaration->definition_free(definition);
	258	}
	259
	260	struct declaration_scope *
	261	new_declaration_scope(struct declaration_scope *parent_scope)
	262	{
	263	struct declaration_scope *scope = g_new(struct declaration_scope, 1);
	264
	265	scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
	266	g_direct_equal, NULL,
	267	(GDestroyNotify) definition_unref);
	268	scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
	269	g_direct_equal, NULL,
	270	(GDestroyNotify) declaration_unref);
	271	scope->variant_declarations = g_hash_table_new_full(g_direct_hash,
	272	g_direct_equal, NULL,
	273	(GDestroyNotify) declaration_unref);
	274	scope->enum_declarations = g_hash_table_new_full(g_direct_hash,
	275	g_direct_equal, NULL,
	276	(GDestroyNotify) declaration_unref);
	277	scope->parent_scope = parent_scope;
	278	return scope;
	279	}
	280
	281	void free_declaration_scope(struct declaration_scope *scope)
	282	{
	283	g_hash_table_destroy(scope->enum_declarations);
	284	g_hash_table_destroy(scope->variant_declarations);
	285	g_hash_table_destroy(scope->struct_declarations);
	286	g_hash_table_destroy(scope->typedef_declarations);
	287	g_free(scope);
	288	}
	289
	290	static
	291	struct declaration_struct *lookup_struct_declaration_scope(GQuark struct_name,
	292	struct declaration_scope *scope)
	293	{
	294	return g_hash_table_lookup(scope->struct_declarations,
	295	(gconstpointer) (unsigned long) struct_name);
	296	}
	297
	298	struct declaration_struct *lookup_struct_declaration(GQuark struct_name,
	299	struct declaration_scope *scope)
	300	{
	301	struct declaration_struct *declaration;
	302
	303	while (scope) {
	304	declaration = lookup_struct_declaration_scope(struct_name, scope);
	305	if (declaration)
	306	return declaration;
	307	scope = scope->parent_scope;
	308	}
	309	return NULL;
	310	}
	311
	312	int register_struct_declaration(GQuark struct_name,
	313	struct declaration_struct *struct_declaration,
	314	struct declaration_scope *scope)
	315	{
	316	if (!struct_name)
	317	return -EPERM;
	318
	319	/* Only lookup in local scope */
	320	if (lookup_struct_declaration_scope(struct_name, scope))
	321	return -EEXIST;
	322
	323	g_hash_table_insert(scope->struct_declarations,
	324	(gpointer) (unsigned long) struct_name,
	325	struct_declaration);
	326	declaration_ref(&struct_declaration->p);
	327	return 0;
	328	}
	329
	330	static
	331	struct declaration_variant *
	332	lookup_variant_declaration_scope(GQuark variant_name,
	333	struct declaration_scope *scope)
	334	{
	335	return g_hash_table_lookup(scope->variant_declarations,
	336	(gconstpointer) (unsigned long) variant_name);
	337	}
	338
	339	struct declaration_variant *
	340	lookup_variant_declaration(GQuark variant_name,
	341	struct declaration_scope *scope)
	342	{
	343	struct declaration_variant *declaration;
	344
	345	while (scope) {
	346	declaration = lookup_variant_declaration_scope(variant_name, scope);
	347	if (declaration)
	348	return declaration;
	349	scope = scope->parent_scope;
	350	}
	351	return NULL;
	352	}
	353
	354	int register_variant_declaration(GQuark variant_name,
	355	struct declaration_variant *variant_declaration,
	356	struct declaration_scope *scope)
	357	{
	358	if (!variant_name)
	359	return -EPERM;
	360
	361	/* Only lookup in local scope */
	362	if (lookup_variant_declaration_scope(variant_name, scope))
	363	return -EEXIST;
	364
	365	g_hash_table_insert(scope->variant_declarations,
	366	(gpointer) (unsigned long) variant_name,
	367	variant_declaration);
	368	declaration_ref(&variant_declaration->p);
	369	return 0;
	370	}
	371
	372	static
	373	struct declaration_enum *
	374	lookup_enum_declaration_scope(GQuark enum_name,
	375	struct declaration_scope *scope)
	376	{
	377	return g_hash_table_lookup(scope->enum_declarations,
	378	(gconstpointer) (unsigned long) enum_name);
	379	}
	380
	381	struct declaration_enum *
	382	lookup_enum_declaration(GQuark enum_name,
	383	struct declaration_scope *scope)
	384	{
	385	struct declaration_enum *declaration;
	386
	387	while (scope) {
	388	declaration = lookup_enum_declaration_scope(enum_name, scope);
	389	if (declaration)
	390	return declaration;
	391	scope = scope->parent_scope;
	392	}
	393	return NULL;
	394	}
	395
	396	int register_enum_declaration(GQuark enum_name,
	397	struct declaration_enum *enum_declaration,
	398	struct declaration_scope *scope)
	399	{
	400	if (!enum_name)
	401	return -EPERM;
	402
	403	/* Only lookup in local scope */
	404	if (lookup_enum_declaration_scope(enum_name, scope))
	405	return -EEXIST;
	406
	407	g_hash_table_insert(scope->enum_declarations,
	408	(gpointer) (unsigned long) enum_name,
	409	enum_declaration);
	410	declaration_ref(&enum_declaration->p);
	411	return 0;
	412	}
	413
	414	static struct definition_scope *
	415	_new_definition_scope(struct definition_scope *parent_scope,
	416	int scope_path_len)
	417	{
	418	struct definition_scope *scope = g_new(struct definition_scope, 1);
	419
	420	scope->definitions = g_hash_table_new_full(g_direct_hash,
	421	g_direct_equal, NULL,
	422	(GDestroyNotify) definition_unref);
	423	scope->parent_scope = parent_scope;
	424	scope->scope_path = g_array_sized_new(FALSE, TRUE, sizeof(GQuark),
	425	scope_path_len);
	426	g_array_set_size(scope->scope_path, scope_path_len);
	427	return scope;
	428	}
	429
	430	struct definition_scope *
	431	new_definition_scope(struct definition_scope *parent_scope,
	432	GQuark field_name)
	433	{
	434	struct definition_scope *scope;
	435	int scope_path_len = 1;
	436
	437	if (parent_scope)
	438	scope_path_len += parent_scope->scope_path->len;
	439	scope = _new_definition_scope(parent_scope, scope_path_len);
	440	if (parent_scope)
	441	memcpy(scope->scope_path, parent_scope->scope_path,
	442	sizeof(GQuark) * (scope_path_len - 1));
	443	g_array_index(scope->scope_path, GQuark, scope_path_len - 1) =
	444	field_name;
	445	return scope;
	446	}
	447
	448	void set_dynamic_definition_scope(struct definition_scope *scope,
	449	GQuark root_name)
	450	{
	451	g_array_set_size(scope->scope_path, 1);
	452	g_array_index(scope->scope_path, GQuark, 0) = root_name;
	453	}
	454
	455	void free_definition_scope(struct definition_scope *scope)
	456	{
	457	g_array_free(scope->scope_path, TRUE);
	458	g_hash_table_destroy(scope->definitions);
	459	g_free(scope);
	460	}