--- rpl/src/formateur.c	2010/01/26 15:22:44	1.1
+++ rpl/src/formateur.c	2017/08/03 17:17:43	1.88
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.28
+  Copyright (C) 1989-2017 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -42,11 +42,15 @@ formateur(struct_processus *s_etat_proce
 	int							parentheses_groupe_gauche;
 	int							parentheses_groupe_droit;
 
+	integer8					(*__type_disp)(struct_processus *, void **);
+
 	logical1					registre45;
 
 	logical4					autorisation_parenthese;
 	logical4					presence_signe;
 
+	logical8					masque_binaire;
+
 	struct_liste_chainee		*l_atome;
 	struct_liste_chainee		*l_element_courant;
 	struct_liste_chainee		*l_liste1;
@@ -70,21 +74,19 @@ formateur(struct_processus *s_etat_proce
 	unsigned char				*registre;
 	unsigned char				tampon[1024 + 1];
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				k;
-	unsigned long				longueur_binaire;
-	unsigned long				longueur_courante;
-	unsigned long				longueur_decimale_courante;
-	unsigned long				*longueurs_maximales;
-	unsigned long				nombre_arguments;
-	unsigned long				nombre_arguments_fonction;
-	unsigned long				nombre_colonnes;
-	unsigned long				nombre_elements;
-	unsigned long				nombre_lignes;
-	unsigned long				offset;
-
-	integer8					masque_binaire;
+	integer8					i;
+	integer8					j;
+	integer8					k;
+	integer8					longueur_chaine;
+	integer8					longueur_courante;
+	integer8					longueur_decimale_courante;
+	integer8					*longueurs_maximales;
+	integer8					nombre_arguments;
+	integer8					nombre_arguments_fonction;
+	integer8					nombre_colonnes;
+	integer8					nombre_elements;
+	integer8					nombre_lignes;
+	integer8					offset;
 
 	chaine = NULL;
 	chaine_formatee = NULL;
@@ -92,7 +94,6 @@ formateur(struct_processus *s_etat_proce
 
 	strcpy(base, " ");
 
-	longueur_binaire = 0;
 	masque_binaire = 0;
 
 	if ((*s_objet).type == ADR)
@@ -104,19 +105,13 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		sprintf(tampon, "%016lX", (*((unsigned long *) ((*s_objet).objet))));
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 3)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus, &chaine,
+				"@ %016llX", (*((unsigned long long *)
+				((*s_objet).objet)))) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
-
-		strcpy(chaine, "@ ");
-		strcat(chaine, tampon);
 	}
 	else if ((*s_objet).type == SLB)
 	{
@@ -127,34 +122,20 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		sprintf(tampon, " %016lX", (unsigned long) (*((struct_bibliotheque *)
-				(*s_objet).objet)).descripteur);
+#		pragma GCC diagnostic push
+#		pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
 
-		chaine = (unsigned char *) malloc((strlen(tampon) + 10)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus, &chaine, "Library $ %016llX [%s]",
+				(unsigned long long) (*((struct_bibliotheque *)
+				(*s_objet).objet)).descripteur, (*((struct_bibliotheque *)
+				(*s_objet).objet)).nom) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
-		strcpy(chaine, "Library $");
-		strcat(chaine, tampon);
-
-		registre = chaine;
+#		pragma GCC diagnostic pop
 
-		if ((chaine = malloc((strlen(registre) + 2 +
-				strlen((*(struct_bibliotheque *) ((*s_objet).objet)).nom)
-				+ 2) * sizeof(unsigned char))) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(NULL);
-		}
-
-		sprintf(chaine, "%s [%s]", registre, (*((struct_bibliotheque *)
-					(*s_objet).objet)).nom);
-		free(registre);
 	}
 	else if ((*s_objet).type == SPH)
 	{
@@ -165,21 +146,20 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		sprintf(tampon, "%016lX", (unsigned long)
-				&((*((struct_semaphore *) (*s_objet).objet)).semaphore));
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 15 +
-				strlen((*((struct_semaphore *) (*s_objet).objet)).nom))
-				* sizeof(unsigned char));
+#		pragma GCC diagnostic push
+#		pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
 
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus,
+				&chaine, "Semaphore $ %016llX '%s'", (unsigned long long)
+				&((*((struct_semaphore *) (*s_objet).objet)).semaphore),
+				(*((struct_semaphore *) (*s_objet).objet)).nom) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
-		sprintf(chaine, "Semaphore $%s '%s'", tampon,
-				(*((struct_semaphore *) (*s_objet).objet)).nom);
+#		pragma GCC diagnostic pop
+
 	}
 	else if ((*s_objet).type == SQL)
 	{
@@ -194,10 +174,14 @@ formateur(struct_processus *s_etat_proce
 				"MYSQL") == 0)
 		{
 #			ifdef MYSQL_SUPPORT
-			sprintf(tampon, "Sql $%016lX (%s)",
-					(long unsigned int) (*((struct_connecteur_sql *)
+			if (alsprintf(s_etat_processus, &chaine, "Sql $ %016llX (%s)",
+					(unsigned long long) (*((struct_connecteur_sql *)
 					(*s_objet).objet)).descripteur.mysql,
-					(*((struct_connecteur_sql *) (*s_objet).objet)).type);
+					(*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
 #			else
 			if ((*s_etat_processus).langue == 'F')
 			{
@@ -217,10 +201,14 @@ formateur(struct_processus *s_etat_proce
 				"POSTGRESQL") == 0)
 		{
 #			ifdef POSTGRESQL_SUPPORT
-			sprintf(tampon, "Sql $%016lX [ %s ]",
-					(long unsigned int) (*((struct_connecteur_sql *)
+			if (alsprintf(s_etat_processus, &chaine, "Sql $ %016llX (%s)",
+					(unsigned long long) (*((struct_connecteur_sql *)
 					(*s_objet).objet)).descripteur.postgresql,
-					(*((struct_connecteur_sql *) (*s_objet).objet)).type);
+					(*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
 #			else
 			if ((*s_etat_processus).langue == 'F')
 			{
@@ -242,17 +230,6 @@ formateur(struct_processus *s_etat_proce
 					(*((struct_connecteur_sql *) (*s_objet).objet))
 					.type));
 		}
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 1)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(NULL);
-		}
-
-		strcpy(chaine, tampon);
 	}
 	else if ((*s_objet).type == PRC)
 	{
@@ -266,41 +243,27 @@ formateur(struct_processus *s_etat_proce
 		if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
 				.processus_detache == d_vrai)
 		{
-			sprintf(tampon, " %016lX", (unsigned long)
+			if (alsprintf(s_etat_processus, &chaine,
+					"Process $ %016llX", (unsigned long long)
 					(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
-					.pid);
-
-			chaine = (unsigned char *) malloc((strlen(tampon) + 10)
-					* sizeof(unsigned char));
-
-			if (chaine == NULL)
+					.pid) < 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
 			}
-
-			strcpy(chaine, "Process $");
-			strcat(chaine, tampon);
 		}
 		else
 		{
-			sprintf(tampon, " %016lX/%016lX",
-					(unsigned long) (*(*((struct_processus_fils *)
+			if (alsprintf(s_etat_processus, &chaine,
+					"Light weight process $ %016llX/%016llX",
+					(unsigned long long) (*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).pid,
-					(unsigned long) (*(*((struct_processus_fils *)
-					(*s_objet).objet)).thread).tid);
-
-			chaine = (unsigned char *) malloc((strlen(tampon) + 23)
-					* sizeof(unsigned char));
-
-			if (chaine == NULL)
+					(unsigned long long) (*(*((struct_processus_fils *)
+					(*s_objet).objet)).thread).tid) < 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
 			}
-
-			strcpy(chaine, "Light weight process $");
-			strcat(chaine, tampon);
 		}
 	}
 	else if ((*s_objet).type == FCH)
@@ -312,21 +275,14 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		sprintf(tampon, " %016lX", (unsigned long) (*((struct_fichier *)
-				((*s_objet).objet))).descripteur);
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 7)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus,
+				&chaine, "File $ %016llX", (unsigned long long)
+				(*((struct_fichier *) ((*s_objet).objet))).descripteur) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
-		strcpy(chaine, "File $");
-		strcat(chaine, tampon);
-
 		registre45 = test_cfsf(s_etat_processus, 45);
 		cf(s_etat_processus, 45);
 
@@ -345,8 +301,10 @@ formateur(struct_processus *s_etat_proce
 			cf(s_etat_processus, 45);
 		}
 
-		if ((format_majuscule = conversion_majuscule(format)) == NULL)
+		if ((format_majuscule = conversion_majuscule(s_etat_processus,
+				format)) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
@@ -452,21 +410,14 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		sprintf(tampon, " %016lX", (unsigned long) (*((struct_socket *)
-				((*s_objet).objet))).socket);
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 9)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus, &chaine,
+				"Socket $ %016llX", (unsigned long long)
+				(*((struct_socket *) ((*s_objet).objet))).socket) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
-		strcpy(chaine, "Socket $");
-		strcat(chaine, tampon);
-
 		registre45 = test_cfsf(s_etat_processus, 45);
 		cf(s_etat_processus, 45);
 
@@ -485,7 +436,8 @@ formateur(struct_processus *s_etat_proce
 			cf(s_etat_processus, 45);
 		}
 
-		if ((format_majuscule = conversion_majuscule(format)) == NULL)
+		if ((format_majuscule = conversion_majuscule(s_etat_processus,
+				format)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -758,6 +710,7 @@ formateur(struct_processus *s_etat_proce
 								|| ((*s_etat_processus).instruction_courante[1]
 								== '-')) ? d_vrai : d_faux;
 
+						(*s_etat_processus).type_en_cours = NON;
 						recherche_type(s_etat_processus);
 
 						if ((*s_etat_processus).erreur_execution != d_ex)
@@ -815,6 +768,7 @@ formateur(struct_processus *s_etat_proce
 							{
 								if ((strcmp(chaine_fonction, "AND") == 0) ||
 										(strcmp(chaine_fonction, "XOR") == 0) ||
+										(strcmp(chaine_fonction, "EQV") == 0) ||
 										(strcmp(chaine_fonction, "OR") == 0))
 								{
 									autorisation_parenthese = d_vrai;
@@ -841,6 +795,7 @@ formateur(struct_processus *s_etat_proce
 										(strcmp(chaine_fonction, "-") == 0) ||
 										(strcmp(chaine_fonction, "AND") == 0) ||
 										(strcmp(chaine_fonction, "XOR") == 0) ||
+										(strcmp(chaine_fonction, "EQV") == 0) ||
 										(strcmp(chaine_fonction, "OR") == 0))
 								{
 									autorisation_parenthese = d_vrai;
@@ -880,7 +835,7 @@ formateur(struct_processus *s_etat_proce
 							chaine_sauvegarde = (unsigned char *)
 									(*s_sous_objet_2).objet;
 
-							if (((*s_sous_objet_2).objet = (void *)
+							if (((*s_sous_objet_2).objet =
 									malloc((strlen(chaine_sauvegarde) + 2 + 1)
 									* sizeof(unsigned char))) == NULL)
 							{
@@ -921,6 +876,7 @@ formateur(struct_processus *s_etat_proce
 								"'%s'", (unsigned char *)
 								(*s_sous_objet_1).objet);
 
+						(*s_etat_processus).type_en_cours = NON;
 						recherche_type(s_etat_processus);
 
 						if ((*s_etat_processus).erreur_execution != d_ex)
@@ -976,6 +932,7 @@ formateur(struct_processus *s_etat_proce
 							{
 								if ((strcmp(chaine_fonction, "AND") == 0) ||
 										(strcmp(chaine_fonction, "XOR") == 0) ||
+										(strcmp(chaine_fonction, "EQV") == 0) ||
 										(strcmp(chaine_fonction, "OR") == 0))
 								{
 									autorisation_parenthese = d_vrai;
@@ -992,6 +949,7 @@ formateur(struct_processus *s_etat_proce
 										(strcmp(chaine_fonction, "-") == 0) ||
 										(strcmp(chaine_fonction, "AND") == 0) ||
 										(strcmp(chaine_fonction, "XOR") == 0) ||
+										(strcmp(chaine_fonction, "EQV") == 0) ||
 										(strcmp(chaine_fonction, "OR") == 0))
 								{
 									autorisation_parenthese = d_vrai;
@@ -1010,7 +968,7 @@ formateur(struct_processus *s_etat_proce
 							chaine_sauvegarde = (unsigned char *)
 									(*s_sous_objet_1).objet;
 
-							if (((*s_sous_objet_1).objet = (void *)
+							if (((*s_sous_objet_1).objet =
 									malloc((strlen(chaine_sauvegarde) + 2 + 1)
 									* sizeof(unsigned char))) == NULL)
 							{
@@ -1034,7 +992,7 @@ formateur(struct_processus *s_etat_proce
 							return(NULL);
 						}
 
-						if (((*s_sous_objet).objet = (void *) malloc((strlen(
+						if (((*s_sous_objet).objet = malloc((strlen(
 								(unsigned char *) (*s_sous_objet_1).objet) +
 								strlen((*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
@@ -1115,7 +1073,7 @@ formateur(struct_processus *s_etat_proce
 						if (autorisation_parenthese == d_vrai)
 						{
 							if (((*s_sous_objet).objet =
-									(void *) malloc((strlen(
+									malloc((strlen(
 									(unsigned char *) (*s_sous_objet_1).objet) +
 									strlen((*((struct_fonction *)
 									(*(*l_element_courant).donnee).objet))
@@ -1139,7 +1097,7 @@ formateur(struct_processus *s_etat_proce
 						else
 						{
 							if (((*s_sous_objet).objet =
-									(void *) malloc((strlen(
+									malloc((strlen(
 									(unsigned char *) (*s_sous_objet_1).objet) +
 									strlen((*((struct_fonction *)
 									(*(*l_element_courant).donnee).objet))
@@ -1218,6 +1176,8 @@ formateur(struct_processus *s_etat_proce
 							(*(*l_element_courant).donnee).objet)).nom_fonction,
 							"XOR") == 0) || (strcmp((*((struct_fonction *)
 							(*(*l_element_courant).donnee).objet)).nom_fonction,
+							"EQV") == 0) || (strcmp((*((struct_fonction *)
+							(*(*l_element_courant).donnee).objet)).nom_fonction,
 							"AND") == 0))
 					{
 						if (depilement(s_etat_processus, &((*s_etat_processus)
@@ -1262,6 +1222,7 @@ formateur(struct_processus *s_etat_proce
 								"'%s'", (unsigned char *)
 								(*s_sous_objet_1).objet);
 
+						(*s_etat_processus).type_en_cours = NON;
 						recherche_type(s_etat_processus);
 
 						if ((*s_etat_processus).erreur_execution != d_ex)
@@ -1307,6 +1268,7 @@ formateur(struct_processus *s_etat_proce
 							}
 
 							if (((strcmp(chaine_fonction, "OR") == 0) ||
+									(strcmp(chaine_fonction, "EQV") == 0) ||
 									(strcmp(chaine_fonction, "XOR") == 0)) &&
 									(strcmp((*((struct_fonction *)
 									(*(*l_element_courant).donnee).objet))
@@ -1337,6 +1299,7 @@ formateur(struct_processus *s_etat_proce
 								"'%s'", (unsigned char *)
 								(*s_sous_objet_2).objet);
 
+						(*s_etat_processus).type_en_cours = NON;
 						recherche_type(s_etat_processus);
 
 						if ((*s_etat_processus).erreur_execution != d_ex)
@@ -1382,6 +1345,7 @@ formateur(struct_processus *s_etat_proce
 							}
 
 							if (((strcmp(chaine_fonction, "OR") == 0) ||
+									(strcmp(chaine_fonction, "EQV") == 0) ||
 									(strcmp(chaine_fonction, "XOR") == 0)) &&
 									(strcmp((*((struct_fonction *)
 									(*(*l_element_courant).donnee).objet))
@@ -1393,14 +1357,14 @@ formateur(struct_processus *s_etat_proce
 
 						liberation(s_etat_processus, s_sous_objet_3);
 
-						if (((*s_sous_objet).objet = (void *) malloc((strlen(
+						if (((*s_sous_objet).objet = malloc((strlen(
 								(unsigned char *) (*s_sous_objet_1).objet) +
 								strlen((*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
 								.nom_fonction) + strlen((unsigned char *)
 								(*s_sous_objet_2).objet) + 2 + 1 +
-								parentheses_groupe_gauche +
-								parentheses_groupe_droit) *
+								((size_t) parentheses_groupe_gauche) +
+								((size_t) parentheses_groupe_droit)) *
 								sizeof(unsigned char))) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -1537,7 +1501,7 @@ formateur(struct_processus *s_etat_proce
 							return(NULL);
 						}
 
-						(*s_sous_objet).objet = (void *) chaine;
+						(*s_sous_objet).objet = chaine;
 
 						if (empilement(s_etat_processus, &((*s_etat_processus)
 								.l_base_pile), s_sous_objet) == d_erreur)
@@ -1557,7 +1521,7 @@ formateur(struct_processus *s_etat_proce
 					return(NULL);
 				}
 
-				if (((*s_sous_objet).objet = (void *) formateur(
+				if (((*s_sous_objet).objet = formateur(
 						s_etat_processus, 0, (*l_element_courant).donnee))
 						== NULL)
 				{
@@ -1585,8 +1549,8 @@ formateur(struct_processus *s_etat_proce
 					ptrl = chaine_sauvegarde;
 					ptre = (unsigned char *) (*s_sous_objet).objet;
 
-					for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
-							i--, *ptre++ = *ptrl++);
+					for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde)) - 2;
+							i > 0; i--, *ptre++ = *ptrl++);
 
 					(*ptre) = d_code_fin_chaine;
 
@@ -1647,7 +1611,6 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		longueur_binaire = longueur_entiers_binaires(s_etat_processus);
 		masque_binaire = masque_entiers_binaires(s_etat_processus);
 
 		if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
@@ -1658,7 +1621,7 @@ formateur(struct_processus *s_etat_proce
 -- Base décimale ---------------------------------------------------------------
 */
 
-			sprintf(tampon, "%llu", (*((logical8 *)
+			sprintf(tampon, "%llu", (*((unsigned long long *)
 					((*s_objet).objet))) & masque_binaire);
 			strcpy(base, "d");
 		}
@@ -1670,7 +1633,7 @@ formateur(struct_processus *s_etat_proce
 -- Base octale -----------------------------------------------------------------
 */
 
-			sprintf(tampon, "%llo", (*((logical8 *)
+			sprintf(tampon, "%llo", (*((unsigned long long *)
 					((*s_objet).objet))) & masque_binaire);
 			strcpy(base, "o");
 		}
@@ -1681,7 +1644,7 @@ formateur(struct_processus *s_etat_proce
 -- Bases hexadécimale et binaire -----------------------------------------------
 */
 
-			sprintf(tampon, "%llX", (*((logical8 *)
+			sprintf(tampon, "%llX", (*((unsigned long long *)
 					((*s_objet).objet))) & masque_binaire);
 
 			if (test_cfsf(s_etat_processus, 43) == d_vrai)
@@ -1703,7 +1666,7 @@ formateur(struct_processus *s_etat_proce
 				strcpy(chaine, tampon);
 				tampon[0] = 0;
 
-				for(i = 0; i < strlen(chaine); i++)
+				for(i = 0; i < (integer8) strlen(chaine); i++)
 				{
 					switch(chaine[i])
 					{
@@ -1819,16 +1782,27 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		chaine = (unsigned char *) malloc((strlen((unsigned char *)
-				((*s_objet).objet)) + 1) * sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
+				(test_cfsf(s_etat_processus, 34) == d_vrai))
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(NULL);
+			if ((chaine = formateur_flux(s_etat_processus,
+					(unsigned char *) (*s_objet).objet, &longueur_chaine))
+					== NULL)
+			{
+				return(NULL);
+			}
 		}
+		else
+		{
+			if ((chaine = malloc((strlen((unsigned char *)
+					((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
 
-		strcpy(chaine, (unsigned char *) ((*s_objet).objet));
+			strcpy(chaine, (unsigned char *) ((*s_objet).objet));
+		}
 	}
 	else if ((*s_objet).type == CPL)
 	{
@@ -1839,7 +1813,7 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+		chaine_formatee = formateur_nombre(s_etat_processus,
 				((struct_complexe16 *) ((*s_objet).objet)), 'C');
 
 		if (chaine_formatee == NULL)
@@ -1874,7 +1848,7 @@ formateur(struct_processus *s_etat_proce
 
 		while(l_element_courant != NULL)
 		{
-			if ((chaine_formatee = formateur(s_etat_processus, 0,
+			if ((chaine_formatee = formateur(s_etat_processus, offset_initial,
 				   	(*l_element_courant).donnee)) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -1947,7 +1921,7 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+		chaine_formatee = formateur_nombre(s_etat_processus,
 				((integer8 *) ((*s_objet).objet)), 'I');
 
 		if (chaine_formatee == NULL)
@@ -2008,13 +1982,13 @@ formateur(struct_processus *s_etat_proce
 		}
 
 		strcpy(chaine, "<[ ");
-		offset = strlen(chaine) + offset_initial;
+		offset = ((integer8) strlen(chaine)) + offset_initial;
 
 		for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
 				.nombre_elements; i++)
 		{
 			chaine_sauvegarde = chaine;
-			chaine_formatee = formateur(s_etat_processus, offset,
+			chaine_formatee = formateur(s_etat_processus, (long) offset,
 					(*((struct_tableau *) (*s_objet).objet)).elements[i]);
 
 			if (chaine_formatee == NULL)
@@ -2105,7 +2079,7 @@ formateur(struct_processus *s_etat_proce
 					chaine_sauvegarde = chaine;
 
 					chaine = (unsigned char *) malloc(
-							(strlen(chaine_sauvegarde) + 1 + offset)
+							(strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
 							* sizeof(unsigned char));
 
 					if (chaine == NULL)
@@ -2213,12 +2187,12 @@ formateur(struct_processus *s_etat_proce
 
 		l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
 		nombre_elements = 0;
-		offset = strlen(chaine) + offset_initial;
+		offset = ((integer8) strlen(chaine)) + offset_initial;
 
 		while(l_element_courant != NULL)
 		{
 			chaine_sauvegarde = chaine;
-			chaine_formatee = formateur(s_etat_processus, offset,
+			chaine_formatee = formateur(s_etat_processus, (long) offset,
 					(*l_element_courant).donnee);
 
 			if (chaine_formatee == NULL)
@@ -2307,7 +2281,7 @@ formateur(struct_processus *s_etat_proce
 					chaine_sauvegarde = chaine;
 
 					chaine = (unsigned char *) malloc(
-							(strlen(chaine_sauvegarde) + 1 + offset)
+							(strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
 							* sizeof(unsigned char));
 
 					if (chaine == NULL)
@@ -2415,10 +2389,10 @@ formateur(struct_processus *s_etat_proce
 		if (chaine != NULL)
 		{
 			strcpy(chaine, "[[");
-			offset = strlen(chaine) + offset_initial - 1;
+			offset = ((integer8) strlen(chaine)) + offset_initial - 1;
 
-			if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
-					nombre_colonnes)) == NULL)
+			if ((longueurs_maximales = malloc(sizeof(integer8) * 2 *
+					((size_t) nombre_colonnes))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme =
 						d_es_allocation_memoire;
@@ -2437,7 +2411,7 @@ formateur(struct_processus *s_etat_proce
 					for(j = 0; j < nombre_colonnes; j++)
 					{
 						chaine_formatee = formateur_nombre(s_etat_processus,
-								(void *) &(((struct_complexe16 **)
+								&(((struct_complexe16 **)
 								((*((struct_matrice *)
 								((*s_objet).objet))).tableau))[i][j]), 'C');
 
@@ -2448,7 +2422,7 @@ formateur(struct_processus *s_etat_proce
 							return(NULL);
 						}
 
-						longueur_courante = strlen(chaine_formatee);
+						longueur_courante = (integer8) strlen(chaine_formatee);
 						longueur_decimale_courante = 0;
 
 						if ((ptrl = index(chaine_formatee,
@@ -2482,7 +2456,7 @@ formateur(struct_processus *s_etat_proce
 				for(j = 0; j < nombre_colonnes; j++)
 				{
 					chaine_formatee = formateur_nombre(s_etat_processus,
-							(void *) &(((struct_complexe16 **)
+							&(((struct_complexe16 **)
 							((*((struct_matrice *)
 							((*s_objet).objet))).tableau))[i][j]), 'C');
 
@@ -2493,7 +2467,7 @@ formateur(struct_processus *s_etat_proce
 						return(NULL);
 					}
 
-					longueur_courante = strlen(chaine_formatee);
+					longueur_courante = (integer8) strlen(chaine_formatee);
 					longueur_decimale_courante = 0;
 
 					if ((ptrl = index(chaine_formatee,
@@ -2512,9 +2486,10 @@ formateur(struct_processus *s_etat_proce
 
 						chaine = (unsigned char *) malloc(
 								(strlen(chaine_sauvegarde) +
-								longueur_courante + longueur_decimale_courante +
-								longueurs_maximales[2 * j] +
-								longueurs_maximales[(2 * j) + 1] + 2)
+								((size_t) longueur_courante) +
+								((size_t) longueur_decimale_courante) +
+								((size_t) longueurs_maximales[2 * j]) +
+								((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
 								* sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2547,7 +2522,8 @@ formateur(struct_processus *s_etat_proce
 					{
 						chaine = (unsigned char *) malloc(
 								(strlen(chaine_sauvegarde) +
-								longueur_courante + longueur_decimale_courante
+								((size_t) longueur_courante) +
+								((size_t) longueur_decimale_courante)
 								+ 2) * sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2573,8 +2549,8 @@ formateur(struct_processus *s_etat_proce
 					if (test_cfsf(s_etat_processus, 45) == d_vrai)
 					{
 						chaine = (unsigned char *) malloc(
-								(strlen(chaine_sauvegarde) + 5 + offset)
-								* sizeof(unsigned char));
+								(strlen(chaine_sauvegarde) + 5 +
+								((size_t) offset)) * sizeof(unsigned char));
 
 						if (chaine == NULL)
 						{
@@ -2649,10 +2625,10 @@ formateur(struct_processus *s_etat_proce
 		if (chaine != NULL)
 		{
 			strcpy(chaine, "[[");
-			offset = strlen(chaine) + offset_initial - 1;
+			offset = ((integer8) strlen(chaine)) + offset_initial - 1;
 
-			if ((longueurs_maximales = malloc(sizeof(unsigned long) *
-					nombre_colonnes)) == NULL)
+			if ((longueurs_maximales = malloc(sizeof(integer8) *
+					((size_t) nombre_colonnes))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -2670,7 +2646,7 @@ formateur(struct_processus *s_etat_proce
 					for(j = 0; j < nombre_colonnes; j++)
 					{
 						chaine_formatee = formateur_nombre(s_etat_processus,
-								(void *) &(((integer8 **) ((*((struct_matrice *)
+								&(((integer8 **) ((*((struct_matrice *)
 								((*s_objet).objet))).tableau))[i][j]), 'I');
 
 						if (chaine_formatee == NULL)
@@ -2680,7 +2656,7 @@ formateur(struct_processus *s_etat_proce
 							return(NULL);
 						}
 
-						longueur_courante = strlen(chaine_formatee);
+						longueur_courante = (integer8) strlen(chaine_formatee);
 						free(chaine_formatee);
 
 						if (longueurs_maximales[j] < longueur_courante)
@@ -2696,7 +2672,7 @@ formateur(struct_processus *s_etat_proce
 				for(j = 0; j < nombre_colonnes; j++)
 				{
 					chaine_formatee = formateur_nombre(s_etat_processus,
-							(void *) &(((integer8 **) ((*((struct_matrice *)
+							&(((integer8 **) ((*((struct_matrice *)
 							((*s_objet).objet))).tableau))[i][j]), 'I');
 
 					if (chaine_formatee == NULL)
@@ -2706,14 +2682,15 @@ formateur(struct_processus *s_etat_proce
 						return(NULL);
 					}
 
-					longueur_courante = strlen(chaine_formatee);
+					longueur_courante = (integer8) strlen(chaine_formatee);
 					chaine_sauvegarde = chaine;
 
 					if (test_cfsf(s_etat_processus, 45) == d_vrai)
 					{
 						chaine = (unsigned char *) malloc(
-								(strlen(chaine_sauvegarde) + longueur_courante
-								+ longueurs_maximales[j] + 2)
+								(strlen(chaine_sauvegarde) +
+								((size_t) longueur_courante)
+								+ ((size_t) longueurs_maximales[j]) + 2)
 								* sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2737,7 +2714,8 @@ formateur(struct_processus *s_etat_proce
 					else
 					{
 						chaine = (unsigned char *) malloc(
-								(strlen(chaine_sauvegarde) + longueur_courante
+								(strlen(chaine_sauvegarde) +
+								((size_t) longueur_courante)
 								+ 2) * sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2763,8 +2741,8 @@ formateur(struct_processus *s_etat_proce
 					if (test_cfsf(s_etat_processus, 45) == d_vrai)
 					{
 						chaine = (unsigned char *) malloc(
-								(strlen(chaine_sauvegarde) + 5 + offset)
-								* sizeof(unsigned char));
+								(strlen(chaine_sauvegarde) + 5 +
+								((size_t) offset)) * sizeof(unsigned char));
 
 						if (chaine == NULL)
 						{
@@ -2839,10 +2817,10 @@ formateur(struct_processus *s_etat_proce
 		if (chaine != NULL)
 		{
 			strcpy(chaine, "[[");
-			offset = strlen(chaine) + offset_initial - 1;
+			offset = ((integer8) strlen(chaine)) + offset_initial - 1;
 
-			if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
-					nombre_colonnes)) == NULL)
+			if ((longueurs_maximales = malloc(sizeof(integer8) * 2 *
+					((size_t) nombre_colonnes))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -2860,7 +2838,7 @@ formateur(struct_processus *s_etat_proce
 					for(j = 0; j < nombre_colonnes; j++)
 					{
 						chaine_formatee = formateur_nombre(s_etat_processus,
-								(void *) &(((real8 **) ((*((struct_matrice *)
+								&(((real8 **) ((*((struct_matrice *)
 								((*s_objet).objet))).tableau))[i][j]), 'R');
 
 						if (chaine_formatee == NULL)
@@ -2870,7 +2848,7 @@ formateur(struct_processus *s_etat_proce
 							return(NULL);
 						}
 
-						longueur_courante = strlen(chaine_formatee);
+						longueur_courante = (integer8) strlen(chaine_formatee);
 						longueur_decimale_courante = 0;
 
 						if ((ptrl = index(chaine_formatee,
@@ -2904,7 +2882,7 @@ formateur(struct_processus *s_etat_proce
 				for(j = 0; j < nombre_colonnes; j++)
 				{
 					chaine_formatee = formateur_nombre(s_etat_processus,
-							(void *) &(((real8 **) ((*((struct_matrice *)
+							&(((real8 **) ((*((struct_matrice *)
 							((*s_objet).objet))).tableau))[i][j]), 'R');
 
 					if (chaine_formatee == NULL)
@@ -2914,7 +2892,7 @@ formateur(struct_processus *s_etat_proce
 						return(NULL);
 					}
 
-					longueur_courante = strlen(chaine_formatee);
+					longueur_courante = (integer8) strlen(chaine_formatee);
 					longueur_decimale_courante = 0;
 
 					if ((ptrl = index(chaine_formatee,
@@ -2932,9 +2910,10 @@ formateur(struct_processus *s_etat_proce
 					{
 						chaine = (unsigned char *) malloc(
 								(strlen(chaine_sauvegarde) +
-								longueur_courante + longueur_decimale_courante +
-								longueurs_maximales[2 * j] +
-								longueurs_maximales[(2 * j) + 1] + 2)
+								((size_t) longueur_courante) +
+								((size_t) longueur_decimale_courante) +
+								((size_t) longueurs_maximales[2 * j]) +
+								((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
 								* sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2967,7 +2946,8 @@ formateur(struct_processus *s_etat_proce
 					{
 						chaine = (unsigned char *) malloc(
 								(strlen(chaine_sauvegarde) +
-								 longueur_courante + longueur_decimale_courante
+								((size_t) longueur_courante) +
+								((size_t) longueur_decimale_courante)
 								+ 2) * sizeof(unsigned char));
 
 						if (chaine == NULL)
@@ -2993,8 +2973,8 @@ formateur(struct_processus *s_etat_proce
 					if (test_cfsf(s_etat_processus, 45) == d_vrai)
 					{
 						chaine = (unsigned char *) malloc(
-								(strlen(chaine_sauvegarde) + 5 + offset)
-								* sizeof(unsigned char));
+								(strlen(chaine_sauvegarde) + 5 +
+								((size_t) offset)) * sizeof(unsigned char));
 						
 						if (chaine == NULL)
 						{
@@ -3052,20 +3032,14 @@ formateur(struct_processus *s_etat_proce
 	}
 	else if ((*s_objet).type == MTX)
 	{
-		sprintf(tampon, " %016lX", (unsigned long)
-				&((*((struct_mutex *) (*s_objet).objet)).mutex));
-
-		chaine = (unsigned char *) malloc((strlen(tampon) + 8)
-				* sizeof(unsigned char));
-
-		if (chaine == NULL)
+		if (alsprintf(s_etat_processus, &chaine,
+				"Mutex $ %016llX owned by $ %016llX",
+				&((*((struct_mutex *) (*s_objet).objet)).mutex),
+				(logical8) (*((struct_mutex *) (*s_objet).objet)).tid) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
-
-		strcpy(chaine, "Mutex $");
-		strcat(chaine, tampon);
 	}
 	else if ((*s_objet).type == NOM)
 	{
@@ -3112,7 +3086,7 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+		chaine_formatee = formateur_nombre(s_etat_processus,
 				((real8 *) ((*s_objet).objet)), 'R');
 
 		if (chaine_formatee == NULL)
@@ -3153,7 +3127,7 @@ formateur(struct_processus *s_etat_proce
 
 			for(i = 0; i < nombre_colonnes; i++)
 			{
-				chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+				chaine_formatee = formateur_nombre(s_etat_processus,
 						&(((struct_complexe16 *) ((*((struct_vecteur *)
 						((*s_objet).objet))).tableau))[i]), 'C');
 
@@ -3220,7 +3194,7 @@ formateur(struct_processus *s_etat_proce
 
 			for(i = 0; i < nombre_colonnes; i++)
 			{
-				chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+				chaine_formatee = formateur_nombre(s_etat_processus,
 						&(((integer8 *) ((*((struct_vecteur *)
 						((*s_objet).objet))).tableau))[i]), 'I');
 
@@ -3287,7 +3261,7 @@ formateur(struct_processus *s_etat_proce
 
 			for(i = 0; i < nombre_colonnes; i++)
 			{
-				chaine_formatee = formateur_nombre(s_etat_processus, (void *)
+				chaine_formatee = formateur_nombre(s_etat_processus,
 						&(((real8 *) ((*((struct_vecteur *)
 						((*s_objet).objet))).tableau))[i]), 'R');
 
@@ -3324,8 +3298,7 @@ formateur(struct_processus *s_etat_proce
 
 			if (chaine == NULL)
 			{
-				(*s_etat_processus).erreur_systeme =
-						d_es_allocation_memoire;
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
 			}
 
@@ -3334,6 +3307,77 @@ formateur(struct_processus *s_etat_proce
 			strcat(chaine, " ]");
 		}
 	}
+	else if ((*s_objet).type == NON)
+	{
+		if ((chaine = malloc((strlen("System object") + 1)
+				* sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		strcpy(chaine, "System object");
+	}
+	else if ((*s_objet).type == EXT)
+	{
+		l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+		while(l_element_courant != NULL)
+		{
+			if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+					.descripteur == (*s_objet).descripteur_bibliotheque)
+			{
+				if ((__type_disp = dlsym((*s_objet).descripteur_bibliotheque,
+						"__type_disp")) == NULL)
+				{
+					// Symbole externe non affichable
+
+					if ((chaine = malloc((strlen(
+							"External symbol (disp function not found)") + 1)
+							* sizeof(unsigned char))) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return(NULL);
+					}
+
+					strcpy(chaine, "External symbol (disp function not found)");
+				}
+				else
+				{
+					// Symbole externe affichable
+					void		**arg;
+
+					arg = (void **) &s_objet;
+					__type_disp(s_etat_processus, arg);
+					chaine = (unsigned char *) (*arg);
+				}
+
+				break;
+			}
+
+			l_element_courant = (*l_element_courant).suivant;
+		}
+
+		if (l_element_courant == NULL)
+		{
+			// Symbole externe non affichable
+
+			if ((chaine = malloc((strlen("External symbol") + 1)
+					* sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme =
+						d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			strcpy(chaine, "External symbol");
+		}
+	}
+	else
+	{
+		BUG(1, uprintf("Unknown symbol type\n"));
+	}
 
 	return(chaine);
 }
@@ -3387,7 +3431,7 @@ formateur_nombre(struct_processus *s_eta
 			strcpy(construction_chaine, "(");
 
 			tampon = formateur_reel(s_etat_processus,
-					(void *) &((*((struct_complexe16 *)
+					&((*((struct_complexe16 *)
 					valeur_numerique)).partie_reelle), 'R');
 
 			if (tampon == NULL)
@@ -3425,7 +3469,7 @@ formateur_nombre(struct_processus *s_eta
 			}
 
 			tampon = formateur_reel(s_etat_processus,
-					(void *) &((*((struct_complexe16 *)
+					&((*((struct_complexe16 *)
 					valeur_numerique)).partie_imaginaire), 'R');
 
 			if (tampon == NULL)
@@ -3512,18 +3556,18 @@ formateur_reel(struct_processus *s_etat_
 	logical1				i50;
 
 	long					correction;
+	long					dernier_chiffre_significatif;
 	long					exposant;
+	long					i;
+	long					j;
 	long					longueur_utile;
 	long					longueur_utile_limite;
 
 	unsigned char			*chaine;
-	unsigned char			format[16 + 1];
+	unsigned char			format[32 + 1];
 	unsigned char			mode[3 + 1];
 	unsigned char			*ptr;
-	unsigned char			tampon[16 + 1];
-
-	unsigned long			i;
-	unsigned long			j;
+	unsigned char			tampon[32 + 1];
 
 	chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
 
@@ -3536,6 +3580,30 @@ formateur_reel(struct_processus *s_etat_
 
 	if (type == 'R')
 	{
+#		ifdef FP_INFINITE
+		int		signe;
+
+		if ((signe = isinf((*((real8 *) valeur_numerique)))) != 0)
+		{
+			if (signe > 0)
+			{
+				strcpy(chaine, "infinity");
+			}
+			else
+			{
+				strcpy(chaine, "-infinity");
+			}
+
+			return(chaine);
+		}
+#		endif
+
+		if (isnan((*((real8 *) valeur_numerique))))
+		{
+			strcpy(chaine, "undef");
+			return(chaine);
+		}
+
 		tampon_reel = *((real8 *) valeur_numerique);
 
 		if (tampon_reel > ((real8) 0))
@@ -3551,7 +3619,7 @@ formateur_reel(struct_processus *s_etat_
 			exposant = 0;
 		}
 
-		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
 	}
 	else
 	{
@@ -3559,18 +3627,27 @@ formateur_reel(struct_processus *s_etat_
 
 		if (tampon_entier > ((integer8) 0))
 		{
-			exposant = (long) floor(log10(tampon_entier));
+			exposant = (long) floor(log10((double) tampon_entier));
 		}
 		else if (tampon_entier < ((integer8) 0))
 		{
-			exposant = (long) floor(log10(-tampon_entier));
+			if (tampon_entier != INT64_MIN)
+			{
+				exposant = (long) floor(log10((double) -tampon_entier));
+			}
+			else
+			{
+				tampon_reel = (real8) tampon_entier;
+				exposant = (long) floor(log10(-tampon_reel));
+			}
 		}
 		else
 		{
 			exposant = 0;
 		}
 
-		mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
+				pow(10, (double) exposant);
 	}
 
 	longueur_utile = 0;
@@ -3644,9 +3721,42 @@ formateur_reel(struct_processus *s_etat_
 		}
 	}
 
+	// Test portant sur le nombre de chiffres significatifs dans
+	// le cas du format STD pour que 1.2E-15 apparaisse en notation
+	// SCI car il y a une perte de précision dans l'affichage.
+
+	if ((strcmp(mode, "STD") == 0) && (type == 'R'))
+	{
+		if (abs(*((real8 *) valeur_numerique)) < 1)
+		{
+			dernier_chiffre_significatif = -exposant;
+			sprintf(tampon, ".%f", mantisse);
+
+			ptr = &(tampon[strlen(tampon) - 1]);
+
+			while((*ptr) != '.')
+			{
+				if ((*ptr) != '0')
+				{
+					dernier_chiffre_significatif++;
+				}
+
+				ptr--;
+			}
+		}
+		else
+		{
+			dernier_chiffre_significatif = 0;
+		}
+	}
+	else
+	{
+		dernier_chiffre_significatif = 0;
+	}
+
 	if ((strcmp(mode, "SCI") == 0) ||
 			((strcmp(mode, "STD") == 0) && ((exposant >
-			longueur_utile_limite) ||
+			longueur_utile_limite) || (dernier_chiffre_significatif > 15) ||
 			(exposant < -longueur_utile_limite))) ||
 			((strcmp(mode, "FIX") == 0) &&
 			((exposant >= longueur_utile_limite) ||
@@ -3690,7 +3800,7 @@ formateur_reel(struct_processus *s_etat_
 
 		sprintf(format, "%%.%luf", longueur_utile);
 
-		sprintf(tampon, format, (mantisse * pow(10, exposant)));
+		sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
 		strcpy(chaine, tampon);
 	}
 	else if (strcmp(mode, "ENG") == 0)
@@ -3713,7 +3823,7 @@ formateur_reel(struct_processus *s_etat_
 		longueur_utile -= correction;
 		sprintf(format, "%%.%luf", longueur_utile);
 
-		sprintf(tampon, format, (mantisse * pow(10, correction)));
+		sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
 		strcpy(chaine, tampon);
 		strcat(chaine, "E");
 		sprintf(tampon, "%ld", (exposant - correction));
@@ -3733,8 +3843,15 @@ formateur_reel(struct_processus *s_etat_
 
 			if (exposant >= 0)
 			{
-				sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
-						- 1));
+				if ((exposant + 1) < longueur_utile_limite)
+				{
+					sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
+							- 1));
+				}
+				else
+				{
+					strcpy(format, "%.0f.");
+				}
 			}
 			else
 			{
@@ -3743,7 +3860,7 @@ formateur_reel(struct_processus *s_etat_
 
 			sprintf(tampon, format, *((real8 *) valeur_numerique));
 
-			i = strlen(tampon) - 1;
+			i = ((long) strlen(tampon)) - 1;
 			while(tampon[i] == '0')
 			{
 				tampon[i] = d_code_fin_chaine;
@@ -3752,19 +3869,20 @@ formateur_reel(struct_processus *s_etat_
 
 			if (ds_imposition_separateur_decimal == d_faux)
 			{
-				i = strlen(tampon) - 1;
+				i = ((long) strlen(tampon)) - 1;
 				if (tampon[i] == '.')
 				{
 					tampon[i] = d_code_fin_chaine;
 				}
 			}
 		}
+
 		strcpy(chaine, tampon);
 	}
 
 	if (test_cfsf(s_etat_processus, 48) == d_vrai)
 	{
-		for(i = 0; i < strlen(chaine); i++)
+		for(i = 0; i < (long) strlen(chaine); i++)
 		{
 			if (chaine[i] == '.')
 			{