#define TYPE_DECLARATION
#include "src/rplexternals.h"
#include "sets.h"

// Les objets de type ensemble sont délimités par ([ ]) et ne contiennent
// que des entiers.

// Attention : ces fonctions sont à écrire directement en C et non
// en RPL/C car elles interviennent dans le noyau RPL/2.

declareTypeExtension(parse)
	if ((*rptr) == '(')
	{
		rptr++;

		if ((*rptr) == '[')
		{
			rptr++;
			while((*rptr) != 0)
			{
				switch (*rptr)
				{
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
					case ' ':
					{
						break;
					}

					case ']':
					{
						rptr++;

						if ((*rptr) == ')')
						{
							rptr++;
							return(sizeOfParse);
						}
						else
						{
							parseError;
						}
					}

					default:
					{
						parseError;
					}
				}

				rptr++;
			}
		}
	}
endTypeExtension

static int
fonction_ordre(const void *a, const void *b)
{
	if ((*((integer8 *) a)) < (*((integer8 *) b)))
	{
		return(-1);
	}
	if ((*((integer8 *) a)) > (*((integer8 *) b)))
	{
		return(1);
	}

	return(0);
}

declareTypeExtension(new)
	// Si le premier caractère de la chaîne est '(' et que le dernier est ')',
	// on les retire.

	char			*tmp;

	integer8		current_value;
	integer8		i;
	integer8		j;
	integer8		nb_elements;
	integer8		*vecteur;

	if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))
	{
		if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
				== NULL)
		{
			typeError;
		}

		// Sauvegarde de l'instruction courante.
		strcpy(tmp, iptr);

		// Création d'une nouvelle instruction courante amputée de ses premier
		// et dernier caractères.
		memmove(iptr, iptr + 1, strlen(iptr) - 2);
		*(iptr + strlen(iptr) - 2) = 0;

		searchType(free(iptr), iptr = tmp);

		// Restauration de l'instruction courante
		free(iptr);
		iptr = tmp;

		// On doit avoir un vecteur d'entier au niveau 1 de la pile.
		// Si ce n'est pas le cas, il y a une erreur.

		if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN)
		{
			typeError;
		}

		nb_elements = (*((struct_vecteur *) (*(*(*s_etat_processus)
				.l_base_pile).donnee).objet)).taille;

		if (nb_elements > 0)
		{
			if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL)
			{
				typeError;
			}

			for(i = 0; i < nb_elements; i++)
			{
				vecteur[i] = ((integer8 *) (*((struct_vecteur *)
						(*(*(*s_etat_processus)
						.l_base_pile).donnee).objet)).tableau)[i];
			}

			qsort(vecteur, nb_elements, sizeof(integer8), fonction_ordre);

			// Élimination des doublons

			current_value = vecteur[0];

			for(i = 1, j = 1; i < nb_elements; i++)
			{
				if (vecteur[i] != current_value)
				{
					vecteur[j++] = vecteur[i];
					current_value = vecteur[i];
				}
			}

			nb_elements = j;

			if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8)))
					== NULL)
			{
				typeError;
			}

			free(vecteur);
		}
		else
		{
			// cas de l'ensemble vide
			if ((vecteur = malloc(0)) == NULL)
			{
				typeError;
			}
		}

		if (((*arg) = malloc(sizeof(set_t))) == NULL)
		{
			typeError;
		}

		(**((set_t **) arg)).size = nb_elements;
		(**((set_t **) arg)).values = vecteur;

		instruction_drop(s_etat_processus);
		typeFound(ISET);
	}

	typeError;
endTypeExtension

declareTypeExtension(dup)
	integer8		i;

	struct_objet	*n_arg;

	if ((n_arg = allocation(s_etat_processus, EXT)) == NULL)
	{
		typeError;
	}

	if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL)
	{
		typeError;
	}

	(*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **)
			arg)).objet)).size;
	(*n_arg).descripteur_bibliotheque =
			(**((struct_objet **) arg)).descripteur_bibliotheque;
	(*n_arg).extension_type =
			(**((struct_objet **) arg)).extension_type;

	for(i = 0; i < (*((set_t *) (**((struct_objet **) arg)).objet)).size; i++)
	{
		(*((set_t *) ((*n_arg).objet))).values[i] =
				(*((set_t *) (**((struct_objet **) arg)).objet)).values[i];
	}

	arg = (void **) &n_arg;
	typeSuccess;
endTypeExtension

declareTypeExtension(drop)
	// On ne libère surtout pas struct_objet
	free((*((set_t *) (**((struct_objet **) arg)).objet)).values);
	free((**((struct_objet **) arg)).objet);
	typeSuccess;
endTypeExtension

declareTypeExtension(disp)
	(*arg) = malloc(10);
	strcpy((*arg), "ici");
// formateur_nombre(s_etat_processus, void* valeur, 'I');
	typeSuccess;
endTypeExtension