--- rpl/src/formateur.c	2010/04/07 13:45:02	1.10
+++ rpl/src/formateur.c	2020/01/10 11:15:42	1.96
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.14
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 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;
@@ -67,26 +71,22 @@ formateur(struct_processus *s_etat_proce
 	unsigned char				*format_majuscule;
 	unsigned char				*ptre;
 	unsigned char				*ptrl;
-	unsigned char				*ptr_ecriture;
-	unsigned char				*ptr_lecture;
 	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;
@@ -94,7 +94,6 @@ formateur(struct_processus *s_etat_proce
 
 	strcpy(base, " ");
 
-	longueur_binaire = 0;
 	masque_binaire = 0;
 
 	if ((*s_objet).type == ADR)
@@ -106,7 +105,8 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		if (alsprintf(&chaine, "@ %016lX", (*((unsigned long *)
+		if (alsprintf(s_etat_processus, &chaine,
+				"@ %016llX", (*((unsigned long long *)
 				((*s_objet).objet)))) < 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -122,14 +122,20 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		if (alsprintf(&chaine, "Library $ %016lX [%s]",
-				(unsigned long) (*((struct_bibliotheque *)
+#		pragma GCC diagnostic push
+#		pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
+
+		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);
 		}
+
+#		pragma GCC diagnostic pop
+
 	}
 	else if ((*s_objet).type == SPH)
 	{
@@ -140,13 +146,20 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		if (alsprintf(&chaine, "Semaphore $ %016lX '%s'",
+#		pragma GCC diagnostic push
+#		pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
+
+		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);
 		}
+
+#		pragma GCC diagnostic pop
+
 	}
 	else if ((*s_objet).type == SQL)
 	{
@@ -161,8 +174,8 @@ formateur(struct_processus *s_etat_proce
 				"MYSQL") == 0)
 		{
 #			ifdef MYSQL_SUPPORT
-			if (alsprintf(&chaine, "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) < 0)
 			{
@@ -188,8 +201,8 @@ formateur(struct_processus *s_etat_proce
 				"POSTGRESQL") == 0)
 		{
 #			ifdef POSTGRESQL_SUPPORT
-			if (alsprintf(&chaine, "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) < 0)
 			{
@@ -230,7 +243,8 @@ formateur(struct_processus *s_etat_proce
 		if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
 				.processus_detache == d_vrai)
 		{
-			if (alsprintf(&chaine, "Process $ %016lX", (unsigned long)
+			if (alsprintf(s_etat_processus, &chaine,
+					"Process $ %016llX", (unsigned long long)
 					(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
 					.pid) < 0)
 			{
@@ -240,10 +254,11 @@ formateur(struct_processus *s_etat_proce
 		}
 		else
 		{
-			if (alsprintf(&chaine, "Light weight process $ %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 *)
+					(unsigned long long) (*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).tid) < 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -260,7 +275,8 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		if (alsprintf(&chaine, "File $ %016lX", (unsigned long)
+		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;
@@ -285,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);
 		}
 
@@ -392,9 +410,9 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		if (alsprintf(&chaine, "Socket %016lX",
-				(unsigned long) (*((struct_socket *)
-				((*s_objet).objet))).socket) < 0)
+		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);
@@ -418,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);
@@ -691,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)
@@ -748,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;
@@ -774,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;
@@ -813,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)
 							{
@@ -854,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)
@@ -909,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;
@@ -925,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;
@@ -943,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)
 							{
@@ -967,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))
@@ -1048,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))
@@ -1072,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))
@@ -1151,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)
@@ -1195,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)
@@ -1240,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))
@@ -1270,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)
@@ -1315,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))
@@ -1326,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 =
@@ -1470,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)
@@ -1490,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)
 				{
@@ -1518,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;
 
@@ -1580,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) &&
@@ -1591,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");
 		}
@@ -1603,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");
 		}
@@ -1614,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)
@@ -1636,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])
 					{
@@ -1752,80 +1782,25 @@ formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------
 */
 
-		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);
-		}
-
-		if ((*s_etat_processus).autorisation_conversion_chaine == 'Y')
+		if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
+				(test_cfsf(s_etat_processus, 34) == d_vrai))
 		{
-			ptr_lecture = (unsigned char *) (*s_objet).objet;
-			ptr_ecriture = chaine;
-
-			while((*ptr_lecture) != d_code_fin_chaine)
-			{
-				(*ptr_ecriture) = (*ptr_lecture);
-
-				// Début de la séquence d'échappement
-
-				if ((*ptr_lecture) == '\\')
-				{
-					if ((*(ptr_lecture + 1)) == '"')
-					{
-						ptr_lecture++;
-						(*ptr_ecriture) = '\"';
-					}
-					else if ((*(ptr_lecture + 1)) == 'b')
-					{
-						ptr_lecture++;
-						(*ptr_ecriture) = '\b';
-					}
-					else if ((*(ptr_lecture + 1)) == 'n')
-					{
-						ptr_lecture++;
-						(*ptr_ecriture) = '\n';
-					}
-					else if ((*(ptr_lecture + 1)) == 't')
-					{
-						ptr_lecture++;
-						(*ptr_ecriture) = '\t';
-					}
-					else if ((*(ptr_lecture + 1)) == '\\')
-					{
-						ptr_lecture++;
-					}
-					else
-					{
-						if ((*s_etat_processus).langue == 'F')
-						{
-							printf("+++Information : Séquence d'échappement "
-									"inconnue [%d]\n", (int) getpid());
-						}
-						else
-						{
-							printf("+++Warning : Unknown escape code "
-									"[%d]\n", (int) getpid());
-						}
-					}
-				}
-
-				ptr_ecriture++;
-			   	ptr_lecture++;
-			}
-
-			(*ptr_ecriture) = d_code_fin_chaine;
-
-			if ((chaine = realloc(chaine, (strlen(chaine) + 1) *
-					sizeof(unsigned char))) == NULL)
+			if ((chaine = formateur_flux(s_etat_processus,
+					(unsigned char *) (*s_objet).objet, &longueur_chaine))
+					== NULL)
 			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				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));
 		}
 	}
@@ -1838,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)
@@ -1873,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;
@@ -1946,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)
@@ -2007,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)
@@ -2104,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)
@@ -2212,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)
@@ -2306,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)
@@ -2414,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;
@@ -2436,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');
 
@@ -2447,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,
@@ -2481,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');
 
@@ -2492,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,
@@ -2511,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)
@@ -2546,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)
@@ -2572,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)
 						{
@@ -2648,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);
@@ -2669,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)
@@ -2679,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)
@@ -2695,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)
@@ -2705,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)
@@ -2736,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)
@@ -2762,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)
 						{
@@ -2838,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);
@@ -2859,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)
@@ -2869,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,
@@ -2903,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)
@@ -2913,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,
@@ -2931,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)
@@ -2966,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)
@@ -2992,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)
 						{
@@ -3051,8 +3032,10 @@ formateur(struct_processus *s_etat_proce
 	}
 	else if ((*s_objet).type == MTX)
 	{
-		if (alsprintf(&chaine, "Mutex $ %016lX", (unsigned long)
-				&((*((struct_mutex *) (*s_objet).objet)).mutex)) < 0)
+		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);
@@ -3103,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)
@@ -3144,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');
 
@@ -3211,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');
 
@@ -3278,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');
 
@@ -3315,6 +3298,60 @@ formateur(struct_processus *s_etat_proce
 
 			if (chaine == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			strcpy(chaine, chaine_sauvegarde);
+			free(chaine_sauvegarde);
+			strcat(chaine, " ]");
+		}
+	}
+	else if ((*s_objet).type == REC)
+	{
+		chaine = (unsigned char *) malloc(4 * sizeof(unsigned char));
+
+		if (chaine == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		strcpy(chaine, "|[ ");
+		offset = ((integer8) strlen(chaine)) + offset_initial;
+
+		// L'objet se compose de deux tables à une dimension de
+		// mêmes tailles.
+
+		chaine_sauvegarde = chaine;
+
+		if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
+				(*((struct_record *) (*s_objet).objet)).noms)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
+				+ strlen(chaine_sauvegarde) + 1)
+				* sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
+		free(chaine_sauvegarde);
+		free(chaine_formatee);
+
+		if (test_cfsf(s_etat_processus, 45) == d_vrai)
+		{
+			chaine_sauvegarde = chaine;
+
+			if ((chaine = (unsigned char *) malloc(
+					(strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)))
+					== NULL)
+			{
 				(*s_etat_processus).erreur_systeme =
 						d_es_allocation_memoire;
 				return(NULL);
@@ -3322,8 +3359,153 @@ formateur(struct_processus *s_etat_proce
 
 			strcpy(chaine, chaine_sauvegarde);
 			free(chaine_sauvegarde);
-			strcat(chaine, " ]");
+			strcat(chaine, "\n");
+
+			chaine_sauvegarde = chaine;
+
+			chaine = (unsigned char *) malloc(
+					(strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
+					* sizeof(unsigned char));
+
+			if (chaine == NULL)
+			{
+				(*s_etat_processus).erreur_systeme =
+						d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			strcpy(chaine, chaine_sauvegarde);
+			free(chaine_sauvegarde);
+			ptre = &(chaine[strlen(chaine)]);
+
+			for(k = 0; k < offset; k++, *(ptre++) = ' ');
+
+			(*ptre) = d_code_fin_chaine;
+		}
+		else
+		{
+			chaine_sauvegarde = chaine;
+
+			if ((chaine = (unsigned char *) malloc(
+					(strlen(chaine_sauvegarde) + 2)
+					* sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme =
+						d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			strcpy(chaine, chaine_sauvegarde);
+			free(chaine_sauvegarde);
+			strcat(chaine, " ");
+		}
+
+		chaine_sauvegarde = chaine;
+
+		if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
+				(*((struct_record *) (*s_objet).objet)).donnees)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
+				+ strlen(chaine_sauvegarde) + 1)
+				* sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
+		free(chaine_sauvegarde);
+		free(chaine_formatee);
+
+		chaine_sauvegarde = chaine;
+		chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
+				* sizeof(unsigned char));
+
+		if (chaine == NULL)
+		{
+			(*s_etat_processus).erreur_systeme =
+					d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		strcpy(chaine, chaine_sauvegarde);
+		free(chaine_sauvegarde);
+		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);
@@ -3378,7 +3560,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)
@@ -3416,7 +3598,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)
@@ -3505,6 +3687,8 @@ formateur_reel(struct_processus *s_etat_
 	long					correction;
 	long					dernier_chiffre_significatif;
 	long					exposant;
+	long					i;
+	long					j;
 	long					longueur_utile;
 	long					longueur_utile_limite;
 
@@ -3514,9 +3698,6 @@ formateur_reel(struct_processus *s_etat_
 	unsigned char			*ptr;
 	unsigned char			tampon[32 + 1];
 
-	unsigned long			i;
-	unsigned long			j;
-
 	chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
 
 	if (chaine == NULL)
@@ -3528,6 +3709,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))
@@ -3543,7 +3748,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
 	{
@@ -3551,18 +3756,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;
@@ -3715,7 +3929,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)
@@ -3738,7 +3952,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));
@@ -3758,8 +3972,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
 			{
@@ -3768,7 +3989,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;
@@ -3777,7 +3998,7 @@ 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;
@@ -3790,7 +4011,7 @@ formateur_reel(struct_processus *s_etat_
 
 	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] == '.')
 			{