#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>

#include <expValue.h>
#include <identList.h>
#include <tepal.h>
#include <ident.h>


/*
 * Typdeklaration, etc
 */
union identTypes
{
	s_expVal *    base;
	s_identList * idl;
};

struct ident
{
	char * key;
	int    idx;

	int    queued;

	union identTypes val;
};


/*
 * statische Funktionen (interner gebrauch)
 */

/*
 * nicht statische Funktionen (Interface)
 */

/*
 * Contructors / Destructors for ident
 */
	s_ident *
identNew (int idx, const char * key)
{
	int       keyLen = (key == NULL) ? 2 : 2 + strlen (key);
	s_ident * ident  = (s_ident *) malloc (sizeof (s_ident));

	ident->idx = idx;
	ident->key = (char *) malloc (sizeof (char) * keyLen);

	ident->key[0] = ID_TYP_UNDEF;
	ident->key[1] = '\0';

	if (key != NULL)
		strcpy (ident->key + 1, key);

	ident->queued = 0;

	return ident;
}

	s_ident *
identUndefNew (int idx, const char * key)
{
#ifdef DEBUG2
	printf ("[!DEBUG!] identUndefNew: %d/%s\n", idx, key);
#endif

	return identNew (idx, key);
}

	s_ident *
identExpNew (int idx, const char * key, s_expVal * val)
{
	s_ident * ident = identNew (idx, key);

#ifdef DEBUG2
	printf ("[!DEBUG!] identExpNew: %d/%s\n", idx, key);
#endif

	ident->key[0]   = ID_TYP_EXP;
	ident->val.base = expValueClone (val);

	return ident;
}

	s_ident *
identIdlNew (int idx, const char * key, s_identList * val)
{
	s_ident * ident = identNew (idx, key);

#ifdef DEBUG2
	printf ("[!DEBUG!] identIdlNew: %d/%s\n", idx, key);
#endif

	ident->key[0]  = ID_TYP_IDL;
	ident->val.idl = val;

	return ident;
}

	void
identFree (s_ident * id)
{
#ifdef DEBUG2
	printf ("[!DEBUG!] identFree: %d/%s\n", id->idx, id->key);
#endif

	switch (identGetType (id))
	{
		case ID_TYP_EXP:	expValueFree (id->val.base); break;
		case ID_TYP_IDL:	identListFree (id->val.idl); break;
	}

	free (id->key);
	free (id);
}

/*
 * analyse ident
 */
	int
identIsQueued (s_ident * id)
{
	return id->queued;
}

	void
identEnqueue (s_ident * id)
{
	id->queued ++;
}

	void
identDequeue (s_ident * id)
{
	id->queued --;
}

	int
identGetType (s_ident * id)
{
	return id->key[0];
}

	char *
identGetKey (s_ident * id)
{
	return id->key + 1;
}

	int
identGetIdx (s_ident * id)
{
	return id->idx;
}

/* identifier to value */
	s_expVal *
identExp (s_ident * id)
{
	s_expVal * ret = NULL;

	if (id == NULL) 
		exitError (ERR_UNDEF_VAR, identGetKey (id));

	if (identGetType (id) == ID_TYP_EXP)
	{
		ret = expValueClone (id->val.base);
	}

	return ret;
}

	s_identList *
identIdl (s_ident * id)
{
	s_identList * ret = NULL;

	if (identGetType (id) == ID_TYP_IDL)
	{
		ret = id->val.idl;
	}

	return ret;
}

	s_ident *
identSetExp (s_ident * id, s_expVal * val)
{
	switch (identGetType (id))
	{
		case ID_TYP_EXP:	expValueFree (id->val.base); break;
		case ID_TYP_IDL:	identListFree (id->val.idl); break;
	}

	id->key[0]   = ID_TYP_EXP;
	id->val.base = expValueClone (val);

	return id;
}

	s_ident *
identSetIdl (s_ident * id, s_identList * val)
{
	switch (identGetType (id))
	{
		case ID_TYP_EXP:	expValueFree (id->val.base);
		case ID_TYP_IDL:	identListFree (id->val.idl);
	}

	id->key[0]  = ID_TYP_IDL;
	id->val.idl = val;
	
	return id;
}