/***************************************************************************

    ns.c (libIDL namespace functions)

    Copyright (C) 1998, 1999 Andrew T. Veliath

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id$

***************************************************************************/

#include <assert.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include <errno.h>

#include "rename.h"

#include "util.h"

static int is_inheritance_conflict (IDL_tree p);

IDL_ns IDL_ns_new (void)

{

	IDL_ns ns;

	ns = g_new0 (struct _IDL_ns, 1);

	if (ns == NULL) {

		yyerror ("IDL_ns_new: memory exhausted");

		return NULL;

	}

	IDL_NS (ns).global = IDL_gentree_new (IDL_ident_hash,

					      IDL_ident_equal,

					      IDL_ident_new (""));

	IDL_NS (ns).file =  IDL_NS (ns).current = IDL_NS (ns).global;

	IDL_NS (ns).inhibits = g_hash_table_new (g_direct_hash, g_direct_equal);

	IDL_NS (ns).filename_hash = g_hash_table_new (g_str_hash, g_str_equal);

	return ns;

}

static void filename_hash_free (char *filename, IDL_fileinfo *fi)

{

	g_free (fi->name);

	g_free (fi);

}

void IDL_ns_free (IDL_ns ns)

{

	assert (ns != NULL);

	g_hash_table_foreach (IDL_NS (ns).inhibits, (GHFunc)IDL_tree_free, NULL);

	g_hash_table_destroy (IDL_NS (ns).inhibits);

	g_hash_table_foreach (IDL_NS (ns).filename_hash, (GHFunc) filename_hash_free, NULL);

	g_hash_table_destroy (IDL_NS (ns).filename_hash);

	IDL_tree_free (IDL_NS (ns).global);

	g_free (ns);

}

#define IDL_NS_ASSERTS		do {						\

	assert (ns != NULL);							\

	if (__IDL_is_parsing) {							\

		assert (IDL_NS (ns).global != NULL);				\

		assert (IDL_NS (ns).file != NULL);				\

		assert (IDL_NS (ns).current != NULL);				\

		assert (IDL_NODE_TYPE (IDL_NS (ns).global) == IDLN_GENTREE);	\

		assert (IDL_NODE_TYPE (IDL_NS (ns).file) == IDLN_GENTREE);	\

		assert (IDL_NODE_TYPE (IDL_NS (ns).current) == IDLN_GENTREE);	\

	}									\

} while (0)

int IDL_ns_prefix (IDL_ns ns, const char *s)

{

	char *r;

	int l;

	IDL_NS_ASSERTS;

	if (s == NULL)

		return FALSE;

	if (*s == '"')

		r = g_strdup (s + 1);

	else

		r = g_strdup (s);

	l = strlen (r);

	if (l && r[l - 1] == '"')

		r[l - 1] = 0;

	if (IDL_GENTREE (IDL_NS (ns).current)._cur_prefix)

		g_free (IDL_GENTREE (IDL_NS (ns).current)._cur_prefix);

	IDL_GENTREE (IDL_NS (ns).current)._cur_prefix = r;

	return TRUE;

}

IDL_tree IDL_ns_resolve_this_scope_ident (IDL_ns ns, IDL_tree scope, IDL_tree ident)

{

	IDL_tree p, q;

	IDL_NS_ASSERTS;

	p = scope;

	while (p != NULL) {

		q = IDL_ns_lookup_this_scope (ns, p, ident, NULL);

		if (q != NULL)

			return q;

		p = IDL_NODE_UP (p);

	}

	return p;

}

IDL_tree IDL_ns_resolve_ident (IDL_ns ns, IDL_tree ident)

{

	return IDL_ns_resolve_this_scope_ident (ns, IDL_NS (ns).current, ident);

}

IDL_tree IDL_ns_lookup_this_scope (IDL_ns ns, IDL_tree scope, IDL_tree ident, gboolean *conflict)

{

	IDL_tree p, q;

	IDL_NS_ASSERTS;

	if (conflict)

		*conflict = TRUE;

	if (scope == NULL)

		return NULL;

	assert (IDL_NODE_TYPE (scope) == IDLN_GENTREE);

	/* Search this namespace */

	if (g_hash_table_lookup_extended (

		IDL_GENTREE (scope).children, ident, NULL, (gpointer)&p)) {

		assert (IDL_GENTREE (p).data != NULL);

		assert (IDL_NODE_TYPE (IDL_GENTREE (p).data) == IDLN_IDENT);

		return p;

	}

	/* If there are inherited namespaces, look in those before giving up */

	q = IDL_GENTREE (scope)._import;

	if (!q)

		return NULL;

	assert (IDL_NODE_TYPE (q) == IDLN_LIST);

	for (; q != NULL; q = IDL_LIST (q).next) {

		IDL_tree r;

		assert (IDL_LIST (q).data != NULL);

		assert (IDL_NODE_TYPE (IDL_LIST (q).data) == IDLN_IDENT);

		assert (IDL_IDENT_TO_NS (IDL_LIST (q).data) != NULL);

		assert (IDL_NODE_TYPE (IDL_IDENT_TO_NS (IDL_LIST (q).data)) == IDLN_GENTREE);

		/* Search imported namespace scope q */

		if (g_hash_table_lookup_extended (

			IDL_GENTREE (IDL_IDENT_TO_NS (IDL_LIST (q).data)).children,

			ident, NULL, (gpointer)&p)) {

			assert (IDL_GENTREE (p).data != NULL);

			assert (IDL_NODE_TYPE (IDL_GENTREE (p).data) == IDLN_IDENT);

			/* This needs more work, it won't do full ambiguity detection */

			if (conflict && !is_inheritance_conflict (p))

				*conflict = FALSE;

			return p;

		}

		/* Search up one level */

		if (IDL_NODE_TYPE (IDL_NODE_UP (IDL_LIST (q).data)) == IDLN_INTERFACE &&

		    (r = IDL_ns_lookup_this_scope (

			    ns, IDL_IDENT_TO_NS (IDL_LIST (q).data), ident, conflict)))

			return r;

	}

	return NULL;

}

IDL_tree IDL_ns_lookup_cur_scope (IDL_ns ns, IDL_tree ident, gboolean *conflict)

{

	return IDL_ns_lookup_this_scope (ns, IDL_NS (ns).current, ident, conflict);

}

IDL_tree IDL_ns_place_new (IDL_ns ns, IDL_tree ident)

{

	IDL_tree p, up_save;

	gboolean does_conflict;

	IDL_NS_ASSERTS;

	p = IDL_ns_lookup_cur_scope (ns, ident, &does_conflict);

	if (p != NULL && does_conflict)

		return NULL;

	/* The namespace tree is separate from the primary parse tree,

	   so keep the primary tree node's parent the same */

	up_save = IDL_NODE_UP (ident);

	p = IDL_gentree_chain_child (IDL_NS (ns).current, ident);

	IDL_NODE_UP (ident) = up_save;

	if (p == NULL)

		return NULL;

	assert (IDL_NODE_TYPE (p) == IDLN_GENTREE);

	IDL_IDENT_TO_NS (ident) = p;

	assert (IDL_NODE_UP (IDL_IDENT_TO_NS (ident)) == IDL_NS (ns).current);

	/* Generate default repository ID */

	IDL_IDENT_REPO_ID (ident) =

		IDL_ns_ident_make_repo_id (__IDL_root_ns, p, NULL, NULL, NULL);

	return p;

}

void IDL_ns_push_scope (IDL_ns ns, IDL_tree ns_ident)

{

	IDL_NS_ASSERTS;

	assert (IDL_NODE_TYPE (ns_ident) == IDLN_GENTREE);

	assert (IDL_NODE_TYPE (IDL_GENTREE (ns_ident).data) == IDLN_IDENT);

	assert (IDL_NS (ns).current == IDL_NODE_UP (ns_ident));

	IDL_NS (ns).current = ns_ident;

}

void IDL_ns_pop_scope (IDL_ns ns)

{

	IDL_NS_ASSERTS;

	if (IDL_NODE_UP (IDL_NS (ns).current) != NULL)

		IDL_NS (ns).current = IDL_NODE_UP (IDL_NS (ns).current);

}

IDL_tree IDL_ns_qualified_ident_new (IDL_tree nsid)

{

	IDL_tree l = NULL, item;

	while (nsid != NULL) {

		if (IDL_GENTREE (nsid).data == NULL) {

			nsid = IDL_NODE_UP (nsid);

			continue;

		}

		assert (IDL_GENTREE (nsid).data != NULL);

		assert (IDL_NODE_TYPE (IDL_GENTREE (nsid).data) == IDLN_IDENT);

		item = IDL_list_new (IDL_ident_new (

			g_strdup (IDL_IDENT (IDL_GENTREE (nsid).data).str)));

		l = IDL_list_concat (item, l);

		nsid = IDL_NODE_UP (nsid);

	}

	return l;

}

gchar *IDL_ns_ident_to_qstring (IDL_tree ns_ident, const char *join, int levels)

{

	IDL_tree l, q;

	int len, joinlen;

	char *s;

	int count = 0, start_level;

	if (levels < 0 || levels > 64)

		return NULL;

	if (ns_ident == NULL)

		return NULL;

	if (IDL_NODE_TYPE (ns_ident) == IDLN_IDENT)

		ns_ident = IDL_IDENT_TO_NS (ns_ident);

	assert (IDL_NODE_TYPE (ns_ident) == IDLN_GENTREE);

	l = IDL_ns_qualified_ident_new (ns_ident);

	if (l == NULL)

		return NULL;

	if (join == NULL)

		join = "";

	joinlen = strlen (join);

	for (len = 0, q = l; q != NULL; q = IDL_LIST (q).next) {

		IDL_tree i = IDL_LIST (q).data;

		assert (IDL_NODE_TYPE (q) == IDLN_LIST);

		assert (IDL_NODE_TYPE (i) == IDLN_IDENT);

		if (IDL_IDENT (i).str != NULL)

			len += strlen (IDL_IDENT (i).str) + joinlen;

		++count;

	}

	if (levels == 0)

		start_level = 0;

	else

		start_level = count - levels;

	assert (start_level >= 0 && start_level < count);

	s = g_malloc (len + 1);

	if (s == NULL) {

		IDL_tree_free (l);

		return NULL;

	}

	s[0] = '\0';

	for (q = l; q != NULL; q = IDL_LIST (q).next) {

		IDL_tree i = IDL_LIST (q).data;

		if (start_level > 0) {

			--start_level;

			continue;

		}

		if (s[0] != '\0')

			strcat (s, join);

		strcat (s, IDL_IDENT (i).str);

	}

	IDL_tree_free (l);

	return s;

}

int IDL_ns_scope_levels_from_here (IDL_ns ns, IDL_tree ident, IDL_tree parent)

{

	IDL_tree p, scope_here, scope_ident;

	int levels;

	g_return_val_if_fail (ns != NULL, 1);

	g_return_val_if_fail (ident != NULL, 1);

	while (parent && !IDL_NODE_IS_SCOPED (parent))

		parent = IDL_NODE_UP (parent);

	if (parent == NULL)

		return 1;

	if ((scope_here = IDL_tree_get_scope (parent)) == NULL ||

	    (scope_ident = IDL_tree_get_scope (ident)) == NULL)

		return 1;

	assert (IDL_NODE_TYPE (scope_here) == IDLN_GENTREE);

	assert (IDL_NODE_TYPE (scope_ident) == IDLN_GENTREE);

	for (levels = 1; scope_ident;

	     ++levels, scope_ident = IDL_NODE_UP (scope_ident)) {

		p = IDL_ns_resolve_this_scope_ident (

			ns, scope_here, IDL_GENTREE (scope_ident).data);

		if (p == scope_ident)

			return levels;

	}

	return 1;

}

/* If insertion was made, return true, else there was a collision */

static gboolean heap_insert_ident (IDL_tree interface_ident, GTree *heap, IDL_tree any)

{

	IDL_tree p;

	assert (any != NULL);

	assert (heap != NULL);

	if ((p = g_tree_lookup (heap, any))) {

		char *newi;

		char *i1, *i2;

		char *what1 = "identifier", *what2 = what1;

		char *who1, *who2;

		IDL_tree q;

		assert (IDL_NODE_TYPE (p) == IDLN_IDENT);

		newi = IDL_ns_ident_to_qstring (IDL_IDENT_TO_NS (interface_ident), "::", 0);

		i1 = IDL_ns_ident_to_qstring (IDL_IDENT_TO_NS (p), "::", 0);

		i2 = IDL_ns_ident_to_qstring (IDL_IDENT_TO_NS (any), "::", 0);

		q = p;

		while (q && (IDL_NODE_TYPE (q) == IDLN_IDENT || IDL_NODE_TYPE (q) == IDLN_LIST))

			q = IDL_NODE_UP (q);

		assert (q != NULL);

		IDL_tree_get_node_info (q, &what1, &who1);

		q = any;

		while (q && (IDL_NODE_TYPE (q) == IDLN_IDENT || IDL_NODE_TYPE (q) == IDLN_LIST))

			q = IDL_NODE_UP (q);

		assert (q != NULL);

		IDL_tree_get_node_info (q, &what2, &who2);

		yyerrorv ("Ambiguous inheritance in interface `%s' from %s `%s' and %s `%s'",

			  newi, what1, i1, what2, i2);

		IDL_tree_error (p, "%s `%s' conflicts with", what1, i1);

		IDL_tree_error (any, "%s `%s'", what2, i2);

		g_free (newi); g_free (i1); g_free (i2);

		return FALSE;

	}

	g_tree_insert (heap, any, any);

	return TRUE;

}

static int is_visited_interface (GHashTable *visited_interfaces, IDL_tree scope)

{

	assert (scope != NULL);

	assert (IDL_NODE_TYPE (scope) == IDLN_GENTREE);

	/* If already visited, do not visit again */

	return g_hash_table_lookup_extended (visited_interfaces, scope, NULL, NULL);

}

static void mark_visited_interface (GHashTable *visited_interfaces, IDL_tree scope)

{

	assert (scope != NULL);

	assert (IDL_NODE_TYPE (scope) == IDLN_GENTREE);

	g_hash_table_insert (visited_interfaces, scope, scope);

}

static int is_inheritance_conflict (IDL_tree p)

{

	if (IDL_GENTREE (p).data == NULL)

		return FALSE;

	assert (IDL_NODE_TYPE (IDL_GENTREE (p).data) == IDLN_IDENT);

	if (IDL_NODE_UP (IDL_GENTREE (p).data) == NULL)

		return FALSE;

	if (!(IDL_NODE_TYPE (IDL_NODE_UP (IDL_GENTREE (p).data)) == IDLN_OP_DCL ||

	      (IDL_NODE_UP (IDL_GENTREE (p).data) &&

	       IDL_NODE_TYPE (IDL_NODE_UP (IDL_NODE_UP (IDL_GENTREE (p).data))) == IDLN_ATTR_DCL)))

		return FALSE;

	return TRUE;

}

typedef struct {

	IDL_tree interface_ident;

	GTree *ident_heap;

	int insert_conflict;

} InsertHeapData;

static void insert_heap_cb (IDL_tree ident, IDL_tree p, InsertHeapData *data)

{

	if (!is_inheritance_conflict (p))

		return;

	if (!heap_insert_ident (

		data->interface_ident, data->ident_heap, IDL_GENTREE (p).data))

		data->insert_conflict = 1;

}

/* Return true if adds went okay */

static int IDL_ns_load_idents_to_tables (IDL_tree interface_ident, IDL_tree ident_scope,

					 GTree *ident_heap, GHashTable *visited_interfaces)

{

	IDL_tree q, scope;

	InsertHeapData data;

	assert (ident_scope != NULL);

	assert (IDL_NODE_TYPE (ident_scope) == IDLN_IDENT);

	scope = IDL_IDENT_TO_NS (ident_scope);

	if (!scope)

		return TRUE;

	assert (IDL_NODE_TYPE (scope) == IDLN_GENTREE);

	assert (IDL_GENTREE (scope).data != NULL);

	assert (IDL_NODE_TYPE (IDL_GENTREE (scope).data) == IDLN_IDENT);

	assert (IDL_NODE_UP (IDL_GENTREE (scope).data) != NULL);

	assert (IDL_NODE_TYPE (IDL_NODE_UP (IDL_GENTREE (scope).data)) == IDLN_INTERFACE);

	if (is_visited_interface (visited_interfaces, scope))

		return TRUE;

	/* Search this namespace */

	data.interface_ident = interface_ident;

	data.ident_heap = ident_heap;

	data.insert_conflict = 0;

	g_hash_table_foreach (IDL_GENTREE (scope).children, (GHFunc)insert_heap_cb, &data);

	/* If there are inherited namespaces, look in those before giving up */

	q = IDL_GENTREE (scope)._import;

	if (!q)

		data.insert_conflict = 0;

	else

		assert (IDL_NODE_TYPE (q) == IDLN_LIST);

	/* Add inherited namespace identifiers into heap */

	for (; q != NULL; q = IDL_LIST (q).next) {

		int r;

		assert (IDL_LIST (q).data != NULL);

		assert (IDL_NODE_TYPE (IDL_LIST (q).data) == IDLN_IDENT);

		assert (IDL_IDENT_TO_NS (IDL_LIST (q).data) != NULL);

		assert (IDL_NODE_TYPE (IDL_IDENT_TO_NS (IDL_LIST (q).data)) == IDLN_GENTREE);

		assert (IDL_NODE_TYPE (IDL_NODE_UP (IDL_LIST (q).data)) == IDLN_INTERFACE);

		if (!(r = IDL_ns_load_idents_to_tables (interface_ident, IDL_LIST (q).data,

							ident_heap, visited_interfaces)))

			data.insert_conflict = 1;

	}

	mark_visited_interface (visited_interfaces, scope);

	return data.insert_conflict == 0;

}

int IDL_ns_check_for_ambiguous_inheritance (IDL_tree interface_ident, IDL_tree p)

{

	/* We use a sorted heap to check for namespace collisions,

	   since we must do case-insensitive collision checks.

	   visited_interfaces is a hash of visited interface nodes, so

	   we only visit common ancestors once. */

	GTree *ident_heap;

	GHashTable *visited_interfaces;

	int is_ambiguous = 0;

	if (!p)

		return 0;

	ident_heap = g_tree_new (IDL_ident_cmp);

	visited_interfaces = g_hash_table_new (g_direct_hash, g_direct_equal);

	assert (IDL_NODE_TYPE (p) == IDLN_LIST);

	for (; p;  p = IDL_LIST (p).next) {

		if (!IDL_ns_load_idents_to_tables (interface_ident, IDL_LIST (p).data,

						   ident_heap, visited_interfaces))

			is_ambiguous = 1;

	}

	g_tree_destroy (ident_heap);

	g_hash_table_destroy (visited_interfaces);

	return is_ambiguous;

}

/*

 * Local variables:

 * mode: C

 * c-basic-offset: 8

 * tab-width: 8

 * indent-tabs-mode: t

 * End:

 */