--- rpl/modules/sets/types.rplc	2017/06/30 13:11:25	1.3
+++ rpl/modules/sets/types.rplc	2017/07/02 22:28:20	1.4
@@ -8,6 +8,15 @@
 // Attention : ces fonctions sont à écrire directement en C et non
 // en RPL/C car elles interviennent dans le noyau RPL/2.
 
+/*
+================================================================================
+  Fonction permettant d'extraire un objet d'une suite de caractères
+
+  Cette fonction est utilisée par la routine recherche_instruction_suivante()
+  du RPL/2.
+================================================================================
+*/
+
 declareTypeExtension(parse)
 	if ((*rptr) == '(')
 	{
@@ -62,6 +71,15 @@ declareTypeExtension(parse)
 	}
 endTypeExtension
 
+
+/*
+================================================================================
+  La fonction declareTypeExtension(new) est utilisée par la fonction
+  recherche_type() du RPL/2. Elle se charge d'allouer et d'initialiser
+  le champ objet de la struct_objet allouée par recherche_type().
+================================================================================
+*/
+
 static int
 fonction_ordre(const void *a, const void *b)
 {
@@ -94,7 +112,7 @@ declareTypeExtension(new)
 		if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
 				== NULL)
 		{
-			typeError;
+			typeSystemError;
 		}
 
 		// Sauvegarde de l'instruction courante.
@@ -105,13 +123,13 @@ declareTypeExtension(new)
 		memmove(iptr, iptr + 1, strlen(iptr) - 2);
 		*(iptr + strlen(iptr) - 2) = 0;
 
-		searchType(free(iptr), iptr = tmp);
+		searchType(strcpy(iptr, tmp), free(tmp));
 
 		// Restauration de l'instruction courante
-		free(iptr);
-		iptr = tmp;
+		strcpy(iptr, tmp);
+		free(tmp);
 
-		// On doit avoir un vecteur d'entier au niveau 1 de la pile.
+		// On doit avoir un vecteur d'entiers 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)
@@ -126,7 +144,7 @@ declareTypeExtension(new)
 		{
 			if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL)
 			{
-				typeError;
+				typeSystemError;
 			}
 
 			for(i = 0; i < nb_elements; i++)
@@ -156,23 +174,21 @@ declareTypeExtension(new)
 			if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8)))
 					== NULL)
 			{
-				typeError;
+				typeSystemError;
 			}
-
-			free(vecteur);
 		}
 		else
 		{
 			// cas de l'ensemble vide
 			if ((vecteur = malloc(0)) == NULL)
 			{
-				typeError;
+				typeSystemError;
 			}
 		}
 
 		if (((*arg) = malloc(sizeof(set_t))) == NULL)
 		{
-			typeError;
+			typeSystemError;
 		}
 
 		(**((set_t **) arg)).size = nb_elements;
@@ -185,6 +201,15 @@ declareTypeExtension(new)
 	typeError;
 endTypeExtension
 
+
+/*
+================================================================================
+  Fonction de duplication d'un objet.
+
+  Cet objet doit être alloué puis copié.
+================================================================================
+*/
+
 declareTypeExtension(dup)
 	integer8		i;
 
@@ -192,12 +217,12 @@ declareTypeExtension(dup)
 
 	if ((n_arg = allocation(s_etat_processus, EXT)) == NULL)
 	{
-		typeError;
+		typeSystemError;
 	}
 
 	if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL)
 	{
-		typeError;
+		typeSystemError;
 	}
 
 	(*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **)
@@ -217,17 +242,77 @@ declareTypeExtension(dup)
 	typeSuccess;
 endTypeExtension
 
+
+/*
+================================================================================
+  Fonction de libération d'un objet. À l'instar de la fonction new qui n'alloue
+  pas la struct_objet, la fonction drop ne doit pas la libérer.
+================================================================================
+*/
+
 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
 
+
+/*
+================================================================================
+  Fonction créant une chaîne de caractère depuis l'objet pour affichage
+================================================================================
+*/
+
 declareTypeExtension(disp)
-	(*arg) = malloc(10);
-	strcpy((*arg), "ici");
-// formateur_nombre(s_etat_processus, void* valeur, 'I');
+	int		i;
+
+	string	e;
+	string	s;
+	string	t;
+
+	if ((s = malloc(3 * sizeof(unsigned char))) == NULL)
+	{
+		typeSystemError;
+	}
+
+	strcpy(s, "([");
+
+	for(i = 0; i < (*((set_t *) (*((struct_objet *) (*arg))).objet)).size; i++)
+	{
+		if ((e = (string) integerFormat(&((*((set_t *)
+				(*((struct_objet *) (*arg))).objet)).values[i]))) == NULL)
+		{
+			typeSystemError;
+		}
+
+		t = s;
+
+		if ((s = malloc((strlen(t) + strlen(e) + 2) * sizeof(unsigned char)))
+				== NULL)
+		{
+			typeSystemError;
+		}
+
+		strcpy(s, t);
+		free(t);
+		strcat(s, " ");
+		strcat(s, e);
+		free(e);
+	}
+
+	t = s;
+
+	if ((s = malloc((strlen(t) + 4) * sizeof(unsigned char))) == NULL)
+	{
+		typeSystemError;
+	}
+
+	strcpy(s, t);
+	free(t);
+	strcat(s, " ])");
+
+	(*arg) = s;
 	typeSuccess;
 endTypeExtension
 
+// vim: ts=4