--- rpl/modules/sets/types.rplc	2017/06/29 14:54:42	1.2
+++ rpl/modules/sets/types.rplc	2017/06/30 13:11:25	1.3
@@ -62,22 +62,40 @@ declareTypeExtension(parse)
 	}
 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;
+	char			*tmp;
+
+	integer8		current_value;
+	integer8		i;
+	integer8		j;
+	integer8		nb_elements;
+	integer8		*vecteur;
 
-printf("<1>\n");
 	if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))
 	{
 		if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
 				== NULL)
 		{
-printf("<2>\n");
 			typeError;
 		}
-printf("<3>\n");
 
 		// Sauvegarde de l'instruction courante.
 		strcpy(tmp, iptr);
@@ -87,39 +105,129 @@ printf("<3>\n");
 		memmove(iptr, iptr + 1, strlen(iptr) - 2);
 		*(iptr + strlen(iptr) - 2) = 0;
 
-printf("<4>\n");
-		searchType;
-printf("<5>\n");
+		searchType(free(iptr), iptr = tmp);
 
 		// Restauration de l'instruction courante
 		free(iptr);
-printf("<6>\n");
 		iptr = tmp;
 
-printf("<7>\n");
-		if (((*arg) = malloc(sizeof(integer8))) == NULL)
+		// 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;
 		}
 
-		(*((integer8 *) arg)) = 10;
-printf("<8>\n");
+		(**((set_t **) arg)).size = nb_elements;
+		(**((set_t **) arg)).values = vecteur;
+
 		instruction_drop(s_etat_processus);
-printf("<9>\n");
 		typeFound(ISET);
 	}
 
-printf("<10>\n");
 	typeError;
 endTypeExtension
 
-declareTypeExtension(disp)
-	(*arg) = malloc(10);
-	strcpy((*arg), "ici");
-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
+