--- rpl/src/formateur_fichiers.c	2013/03/19 12:46:32	1.60
+++ rpl/src/formateur_fichiers.c	2015/01/05 13:12:31	1.80
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.19
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -19,7 +19,7 @@
 ================================================================================
 */
 
-#define DEBUG_ERREURS
+
 #include "rpl-conv.h"
 
 
@@ -40,9 +40,10 @@
 
 unsigned char *
 formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
-		struct_objet *s_format, long longueur, long longueur_champ,
+		struct_objet *s_format, integer8 longueur, integer8 longueur_champ,
 		unsigned char format_sortie, unsigned char type,
-		long *longueur_effective, long *recursivite, logical1 export_fichier)
+		integer8 *longueur_effective, integer8 *recursivite,
+		logical1 export_fichier)
 {
 	/*
 	 * Traitement du format des fichiers formatés :
@@ -78,14 +79,13 @@ formateur_fichier(struct_processus *s_et
 	logical1					format_degenere;
 	logical1					presence_signe;
 
-	unsigned long int			longueur_chaine_traitee;
-
 	struct_liste_chainee		*l_atome;
 	struct_liste_chainee		*l_element_courant;
 	struct_liste_chainee		*l_element_courant_format;
 	struct_liste_chainee		*l_liste1;
 	struct_liste_chainee		*l_liste2;
 
+	struct_objet				*s_format_tmp;
 	struct_objet				*s_sous_objet;
 	struct_objet				*s_sous_objet_1;
 	struct_objet				*s_sous_objet_2;
@@ -103,14 +103,15 @@ formateur_fichier(struct_processus *s_et
 	unsigned char				tampon[64 + 1];
 	unsigned char				type_binaire;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				nombre_arguments;
-	unsigned long				nombre_arguments_fonction;
-	unsigned long				nombre_colonnes;
-	unsigned long				nombre_elements;
-	unsigned long				nombre_lignes;
+	integer8					i;
+	integer8					j;
+	integer8					nombre_arguments;
+	integer8					nombre_arguments_fonction;
+	integer8					nombre_colonnes;
+	integer8					nombre_elements;
+	integer8					nombre_lignes;
 
+	integer8					longueur_chaine_traitee;
 	integer8					longueur_fonction;
 	integer8					longueur_liste;
 	integer8					longueur_reelle_chaine;
@@ -233,6 +234,7 @@ formateur_fichier(struct_processus *s_et
 									.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)
@@ -292,7 +294,8 @@ formateur_fichier(struct_processus *s_et
 									if ((strcmp(chaine_fonction, "AND") == 0) ||
 											(strcmp(chaine_fonction, "XOR") ==
 											0) || (strcmp(chaine_fonction, "OR")
-											== 0))
+											== 0) || (strcmp(chaine_fonction,
+											"EQV") == 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -319,7 +322,9 @@ formateur_fichier(struct_processus *s_et
 											|| (strcmp(chaine_fonction, "AND")
 											== 0) || (strcmp(chaine_fonction,
 											"XOR") == 0) || (strcmp(
-											chaine_fonction, "OR") == 0))
+											chaine_fonction, "OR") == 0) ||
+											(strcmp(chaine_fonction, "EQV")
+											== 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -400,6 +405,7 @@ formateur_fichier(struct_processus *s_et
 									"'%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)
@@ -457,7 +463,8 @@ formateur_fichier(struct_processus *s_et
 									if ((strcmp(chaine_fonction, "AND") == 0) ||
 											(strcmp(chaine_fonction, "XOR") ==
 											0) || (strcmp(chaine_fonction, "OR")
-											== 0))
+											== 0) || (strcmp(chaine_fonction,
+											"EQV") == 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -474,7 +481,9 @@ formateur_fichier(struct_processus *s_et
 											|| (strcmp(chaine_fonction, "AND")
 											== 0) || (strcmp(chaine_fonction,
 											"XOR") == 0) || (strcmp(
-											chaine_fonction, "OR") == 0))
+											chaine_fonction, "OR") == 0) ||
+											(strcmp(chaine_fonction, "EQV")
+											== 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -715,7 +724,9 @@ formateur_fichier(struct_processus *s_et
 								"XOR") == 0) || (strcmp((*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
 								.nom_fonction,
-								"AND") == 0))
+								"AND") == 0) || (strcmp((*((struct_fonction *)
+								(*(*l_element_courant).donnee).objet))
+								.nom_fonction, "EQV") == 0))
 						{
 							if (depilement(s_etat_processus,
 									&((*s_etat_processus)
@@ -928,8 +939,8 @@ formateur_fichier(struct_processus *s_et
 						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;
 
@@ -1000,7 +1011,7 @@ formateur_fichier(struct_processus *s_et
 
 			if (format_sortie == 'N')
 			{
-				sprintf(tampon, "%llX", (*((logical8 *)
+				sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
 						((*s_objet).objet))));
 				strcpy(base, "h");
 			}
@@ -1010,8 +1021,8 @@ formateur_fichier(struct_processus *s_et
 				{
 					case 2:
 					{
-						sprintf(tampon, "%llX", (*((logical8 *)
-								((*s_objet).objet))));
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
 
 						chaine = (unsigned char *) malloc((strlen(tampon) + 1)
 								* sizeof(unsigned char));
@@ -1026,7 +1037,7 @@ formateur_fichier(struct_processus *s_et
 						strcpy(chaine, tampon);
 						tampon[0] = 0;
 
-						for(i = 0; i < strlen(chaine); i++)
+						for(i = 0; i < ((integer8) strlen(chaine)); i++)
 						{
 							switch(chaine[i])
 							{
@@ -1120,7 +1131,7 @@ formateur_fichier(struct_processus *s_et
 
 					case 8:
 					{
-						sprintf(tampon, "%llo", (*((logical8 *)
+						sprintf(tampon, "%llo", (*((unsigned long long *)
 								((*s_objet).objet))));
 						strcpy(base, "o");
 						break;
@@ -1128,7 +1139,7 @@ formateur_fichier(struct_processus *s_et
 
 					case 10:
 					{
-						sprintf(tampon, "%llu", (*((logical8 *)
+						sprintf(tampon, "%llu", (*((unsigned long long *)
 								((*s_objet).objet))));
 						strcpy(base, "d");
 						break;
@@ -1136,8 +1147,8 @@ formateur_fichier(struct_processus *s_et
 
 					case 16:
 					{
-						sprintf(tampon, "%llX", (*((logical8 *)
-								((*s_objet).objet))));
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
 						strcpy(base, "h");
 						break;
 					}
@@ -1156,7 +1167,8 @@ formateur_fichier(struct_processus *s_et
 				if ((longueur_champ > 0) && (longueur_champ
 						< (signed) strlen(tampon)))
 				{
-					ptrl = &(tampon[strlen(tampon) - longueur_champ]);
+					ptrl = &(tampon[((integer8) strlen(tampon))
+							- longueur_champ]);
 					ptre = tampon;
 
 					do
@@ -1228,7 +1240,7 @@ formateur_fichier(struct_processus *s_et
 						(*s_objet).objet, longueur_champ)
 						- ((unsigned char *) (*s_objet).objet);
 
-				if ((chaine = malloc((longueur_reelle_chaine + 1) *
+				if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) *
 						sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1237,7 +1249,7 @@ formateur_fichier(struct_processus *s_et
 				}
 
 				strncpy(chaine, (unsigned char *) ((*s_objet).objet),
-						longueur_reelle_chaine);
+						(size_t) longueur_reelle_chaine);
 				chaine[longueur_reelle_chaine] = d_code_fin_chaine;
 			}
 		}
@@ -1588,7 +1600,7 @@ formateur_fichier(struct_processus *s_et
 						return(NULL);
 					}
 
-					position_3 = strlen(format_chaine) - 1;
+					position_3 = ((integer8) strlen(format_chaine)) - 1;
 
 					if (format_chaine[position_3] != ')')
 					{
@@ -1623,7 +1635,7 @@ formateur_fichier(struct_processus *s_et
 
 					if (format_degenere == d_faux)
 					{
-						if (sscanf(&(format_chaine[position_1]), "%ld",
+						if (sscanf(&(format_chaine[position_1]), "%lld",
 								&longueur) != 1)
 						{
 							free(chaine);
@@ -1641,7 +1653,7 @@ formateur_fichier(struct_processus *s_et
 
 					if (strcmp(&(format_chaine[position_2]), "*") != 0)
 					{
-						if (sscanf(&(format_chaine[position_2]), "%ld",
+						if (sscanf(&(format_chaine[position_2]), "%lld",
 								&longueur_champ) != 1)
 						{
 							free(chaine);
@@ -1672,16 +1684,70 @@ formateur_fichier(struct_processus *s_et
 				
 					chaine_sauvegarde = chaine;
 
+					// Si le format_sortie vaut 'N', on remplace le format par
+					// { "native*(*)" }. L'intérêt est de pouvoir traiter une
+					// liste par un format "native*(*)".
+
+					if ((format_sortie == 'N') && ((*(*l_element_courant)
+							.donnee).type == LST))
+					{
+						if ((s_format_tmp = allocation(s_etat_processus, LST))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*s_format_tmp).objet = allocation_maillon(
+								s_etat_processus)) == NULL)
+						{
+							return(NULL);
+						}
+
+						(*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.suivant = NULL;
+
+						if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.donnee = allocation(s_etat_processus, CHN))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*(*((struct_liste_chainee *) (*s_format_tmp)
+								.objet)).donnee).objet = malloc(11 *
+								sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
+
+						strcpy((unsigned char *) (*(*((struct_liste_chainee *)
+								(*s_format_tmp).objet)).donnee).objet,
+								"native*(*)");
+					}
+					else
+					{
+						if ((s_format_tmp = copie_objet(s_etat_processus,
+								s_format, 'P')) == NULL)
+						{
+							return(NULL);
+						}
+					}
+
 					if ((chaine_formatee = formateur_fichier(s_etat_processus,
 							(*l_element_courant).donnee, s_format,
 							longueur, longueur_champ, format_sortie, type,
 							longueur_effective, recursivite, export_fichier))
 							== NULL)
 					{
+						liberation(s_etat_processus, s_format_tmp);
 						free(chaine);
 						return(NULL);
 					}
 
+					liberation(s_etat_processus, s_format_tmp);
+
 					if ((*(*l_element_courant).donnee).type == CHN)
 					{
 						chaine = (unsigned char *)
@@ -1936,7 +2002,7 @@ formateur_fichier(struct_processus *s_et
 							return(NULL);
 						}
 
-						position_3 = strlen(format_chaine);
+						position_3 = (integer8) strlen(format_chaine);
 						format_chaine[--position_3] = d_code_fin_chaine;
 
 						position_2 = position_1;
@@ -1960,7 +2026,7 @@ formateur_fichier(struct_processus *s_et
 
 						if (format_degenere == d_faux)
 						{
-							if (sscanf(&(format_chaine[position_1]), "%ld",
+							if (sscanf(&(format_chaine[position_1]), "%lld",
 									&longueur) != 1)
 							{
 								free(chaine);
@@ -1978,7 +2044,7 @@ formateur_fichier(struct_processus *s_et
 
 						if (strcmp(&(format_chaine[position_2]), "*") != 0)
 						{
-							if (sscanf(&(format_chaine[position_2]), "%ld",
+							if (sscanf(&(format_chaine[position_2]), "%lld",
 									&longueur_champ) != 1)
 							{
 								free(chaine);
@@ -2874,7 +2940,7 @@ formateur_fichier(struct_processus *s_et
 			return(NULL);
 		}
 
-		(*longueur_effective) = strlen(chaine) + 1;
+		(*longueur_effective) = ((integer8) strlen(chaine)) + 1;
 	}
 	else
 	{
@@ -3087,16 +3153,16 @@ formateur_fichier(struct_processus *s_et
 
 			(*longueur_effective) = longueur_champ + 1;
 
-			if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char)))
-					== NULL)
+			if ((chaine = malloc(((size_t) (*longueur_effective))
+				 	* sizeof(unsigned char))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
 			}
 
-			chaine[0] = longueur_champ;
+			chaine[0] = (unsigned char) longueur_champ;
 
-			for(i = 1; i <= (unsigned) (*longueur_effective); i++)
+			for(i = 1; i <= (*longueur_effective); i++)
 			{
 				chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
 						(8 * (longueur_champ - i))) & 0xFF;
@@ -3152,15 +3218,15 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				if ((chaine = malloc(longueur_champ * sizeof(unsigned char)))
-							== NULL)
+				if ((chaine = malloc(((size_t) longueur_champ)
+						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
 					return(NULL);
 				}
 
-				memcpy(chaine, chaine_sauvegarde, longueur_champ);
+				memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
 				longueur_chaine_traitee = longueur_champ;
 				free(chaine_sauvegarde);
 			}
@@ -3169,7 +3235,7 @@ formateur_fichier(struct_processus *s_et
 
 			if (longueur_chaine_traitee < (1LL << 3))
 			{
-				if ((chaine = malloc((longueur_chaine_traitee + 1)
+				if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3177,14 +3243,16 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x80 | (longueur_chaine_traitee & 0x7);
+				chaine[0] = (unsigned char) (0x80 |
+						(longueur_chaine_traitee & 0x7));
 
-				memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee);
+				memcpy(chaine + 1, chaine_sauvegarde,
+						(size_t) longueur_chaine_traitee);
 				longueur_totale = longueur_chaine_traitee + 1;
 			}
 			else if (longueur_chaine_traitee < (1LL << 8))
 			{
-				if ((chaine = malloc((longueur_chaine_traitee + 2)
+				if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3192,15 +3260,16 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x88;
+				chaine[0] = (unsigned char) 0x88;
 				chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);
 
-				memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee);
+				memcpy(chaine + 2, chaine_sauvegarde,
+						(size_t) longueur_chaine_traitee);
 				longueur_totale = longueur_chaine_traitee + 2;
 			}
 			else if (longueur_chaine_traitee < (1LL << 16))
 			{
-				if ((chaine = malloc((longueur_chaine_traitee + 3)
+				if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3208,17 +3277,18 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x89;
+				chaine[0] = (unsigned char) 0x89;
 				chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
 						& 0xFF);
 				chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);
 
-				memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee);
+				memcpy(chaine + 3, chaine_sauvegarde,
+						(size_t) longueur_chaine_traitee);
 				longueur_totale = longueur_chaine_traitee + 3;
 			}
 			else if (longueur_chaine_traitee < (1LL << 32))
 			{
-				if ((chaine = malloc((longueur_chaine_traitee + 5)
+				if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3226,7 +3296,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x8A;
+				chaine[0] = (unsigned char) 0x8A;
 				chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
 						& 0xFF);
 				chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
@@ -3235,12 +3305,13 @@ formateur_fichier(struct_processus *s_et
 						& 0xFF);
 				chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);
 
-				memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee);
+				memcpy(chaine + 5, chaine_sauvegarde,
+						(size_t) longueur_chaine_traitee);
 				longueur_totale = longueur_chaine_traitee + 5;
 			}
 			else
 			{
-				if ((chaine = malloc((longueur_chaine_traitee + 9)
+				if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3248,7 +3319,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x8B;
+				chaine[0] = (unsigned char) 0x8B;
 				chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
 						& 0xFF);
 				chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
@@ -3265,7 +3336,8 @@ formateur_fichier(struct_processus *s_et
 						& 0xFF);
 				chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);
 
-				memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee);
+				memcpy(chaine + 9, chaine_sauvegarde,
+						(size_t) longueur_chaine_traitee);
 				longueur_totale = longueur_chaine_traitee + 9;
 			}
 
@@ -3349,12 +3421,12 @@ formateur_fichier(struct_processus *s_et
 				return(NULL);
 			}
 
-			longueur_fonction = strlen((*((struct_fonction *) (*s_objet).objet))
-					.nom_fonction);
+			longueur_fonction = (integer8) strlen((*((struct_fonction *)
+					(*s_objet).objet)).nom_fonction);
 
 			if (longueur_fonction < (1LL << 3))
 			{
-				if ((chaine = malloc((1 + longueur_fonction + 8)
+				if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3362,7 +3434,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | (longueur_fonction & 0x7);
+				chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
 
 				strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
 						.nom_fonction);
@@ -3370,7 +3442,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else if (longueur_fonction < (1LL << 8))
 			{
-				if ((chaine = malloc((2 + longueur_fonction + 8)
+				if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3378,7 +3450,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x08;
+				chaine[0] = (unsigned char) (0xE0 | 0x08);
 				chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
 
 				strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
@@ -3387,7 +3459,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else if (longueur_fonction < (1LL << 16))
 			{
-				if ((chaine = malloc((3 + longueur_fonction + 8)
+				if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3395,7 +3467,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x09;
+				chaine[0] = (unsigned char ) (0xE0 | 0x09);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
 				chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
 
@@ -3405,7 +3477,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else if (longueur_fonction < (1LL << 32))
 			{
-				if ((chaine = malloc((5 + longueur_fonction + 8)
+				if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3413,7 +3485,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x0A;
+				chaine[0] = (unsigned char) (0xE0 | 0x0A);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
 				chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
 				chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
@@ -3425,7 +3497,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else
 			{
-				if ((chaine = malloc((9 + longueur_fonction + 8)
+				if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3433,7 +3505,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x0B;
+				chaine[0] = (unsigned char) (0xE0 | 0x0B);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
 				chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
 				chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
@@ -3506,23 +3578,24 @@ formateur_fichier(struct_processus *s_et
 
 			if (longueur_liste < (1LL << 3))
 			{
-				chaine[0] = type_binaire | (longueur_liste & 0x7);
+				chaine[0] = (unsigned char) (type_binaire |
+						(longueur_liste & 0x7));
 			}
 			else if (longueur_liste < (1LL << 8))
 			{
-				chaine[0] = type_binaire | 0x08;
+				chaine[0] = (unsigned char) (type_binaire | 0x08);
 			}
 			else if (longueur_liste < (1LL << 16))
 			{
-				chaine[0] = type_binaire | 0x09;
+				chaine[0] = (unsigned char ) (type_binaire | 0x09);
 			}
 			else if (longueur_liste < (1LL << 32))
 			{
-				chaine[0] = type_binaire | 0x0A;
+				chaine[0] = (unsigned char) (type_binaire | 0x0A);
 			}
 			else
 			{
-				chaine[0] = type_binaire | 0x0B;
+				chaine[0] = (unsigned char) (type_binaire | 0x0B);
 			}
 
 			longueur_totale = 1;
@@ -3535,7 +3608,8 @@ formateur_fichier(struct_processus *s_et
 					{
 						longueur_totale += 1;
 
-						if ((chaine = realloc(chaine, longueur_totale *
+						if ((chaine = realloc(chaine,
+								((size_t) longueur_totale) *
 								sizeof(unsigned char))) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -3552,7 +3626,8 @@ formateur_fichier(struct_processus *s_et
 					{
 						longueur_totale += 2;
 
-						if ((chaine = realloc(chaine, longueur_totale *
+						if ((chaine = realloc(chaine,
+								((size_t) longueur_totale) *
 								sizeof(unsigned char))) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -3571,7 +3646,8 @@ formateur_fichier(struct_processus *s_et
 					{
 						longueur_totale += 4;
 
-						if ((chaine = realloc(chaine, longueur_totale *
+						if ((chaine = realloc(chaine,
+								((size_t) longueur_totale) *
 								sizeof(unsigned char))) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -3594,7 +3670,8 @@ formateur_fichier(struct_processus *s_et
 					{
 						longueur_totale += 8;
 
-						if ((chaine = realloc(chaine, longueur_totale *
+						if ((chaine = realloc(chaine,
+								((size_t) longueur_totale) *
 								sizeof(unsigned char))) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -3666,8 +3743,8 @@ formateur_fichier(struct_processus *s_et
 						}
 					}
 
-					if ((chaine = realloc(chaine, (longueur_totale +
-							(*longueur_effective)) * sizeof(unsigned char)))
+					if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
+							(*longueur_effective))) * sizeof(unsigned char)))
 							== NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -3676,7 +3753,7 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					memcpy(&(chaine[longueur_totale]), chaine_formatee,
-							(*longueur_effective));
+							(size_t) (*longueur_effective));
 					longueur_totale += (*longueur_effective);
 					free(chaine_formatee);
 				}
@@ -3753,7 +3830,7 @@ formateur_fichier(struct_processus *s_et
 
 					if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
 					{
-						if (sscanf(&(format_chaine[position_1]), "%ld",
+						if (sscanf(&(format_chaine[position_1]), "%lld",
 								&longueur) != 1)
 						{
 							free(chaine);
@@ -3773,19 +3850,73 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					free(format_chaine);
-				
+
+					// Si le format_sortie vaut 'N', on remplace le format par
+					// { "native*(*)" }. L'intérêt est de pouvoir traiter une
+					// liste par un format "native*(*)".
+
+					if ((format_sortie == 'N') && ((*(*l_element_courant)
+							.donnee).type == LST))
+					{
+						if ((s_format_tmp = allocation(s_etat_processus, LST))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*s_format_tmp).objet = allocation_maillon(
+								s_etat_processus)) == NULL)
+						{
+							return(NULL);
+						}
+
+						(*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.suivant = NULL;
+
+						if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.donnee = allocation(s_etat_processus, CHN))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*(*((struct_liste_chainee *) (*s_format_tmp)
+								.objet)).donnee).objet = malloc(11 *
+								sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
+
+						strcpy((unsigned char *) (*(*((struct_liste_chainee *)
+								(*s_format_tmp).objet)).donnee).objet,
+								"native*(*)");
+					}
+					else
+					{
+						if ((s_format_tmp = copie_objet(s_etat_processus,
+								s_format, 'P')) == NULL)
+						{
+							return(NULL);
+						}
+					}
+
 					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*l_element_courant).donnee, s_format,
+							(*l_element_courant).donnee, s_format_tmp,
 							longueur, longueur_champ, format_sortie, type,
 							longueur_effective, recursivite, export_fichier))
 							== NULL)
 					{
+						liberation(s_etat_processus, s_format_tmp);
 						free(chaine);
 						return(NULL);
 					}
 
+					liberation(s_etat_processus, s_format_tmp);
+
 					if ((chaine = realloc(chaine,
-							(longueur_totale + (*longueur_effective))
+							((size_t) (longueur_totale + (*longueur_effective)))
 							* sizeof(unsigned char))) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -3794,19 +3925,19 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					memcpy(&(chaine[longueur_totale]), chaine_formatee,
-							(*longueur_effective));
+							(size_t) (*longueur_effective));
 					longueur_totale += (*longueur_effective);
 					free(chaine_formatee);
 				}
 
-				nombre_elements++;
-				l_element_courant = (*l_element_courant).suivant;
-
 				if (format_sortie != 'N')
 				{
 					l_element_courant_format =
 							(*l_element_courant_format).suivant;
 				}
+
+				nombre_elements++;
+				l_element_courant = (*l_element_courant).suivant;
 			}
 
 			if (format_sortie != 'N')
@@ -3876,12 +4007,12 @@ formateur_fichier(struct_processus *s_et
 				return(NULL);
 			}
 
-			longueur_fonction = strlen((*((struct_nom *) (*s_objet).objet))
-					.nom);
+			longueur_fonction = (integer8) strlen((*((struct_nom *)
+					(*s_objet).objet)).nom);
 
 			if (longueur_fonction < (1LL << 3))
 			{
-				if ((chaine = malloc((1 + longueur_fonction + 1)
+				if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3889,14 +4020,14 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x50 | (longueur_fonction & 0x7);
+				chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7));
 
 				strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom);
 				(*longueur_effective) = longueur_fonction + 2;
 			}
 			else if (longueur_fonction < (1LL << 8))
 			{
-				if ((chaine = malloc((2 + longueur_fonction + 1)
+				if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3904,7 +4035,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x50 | 0x08;
+				chaine[0] = (unsigned char) (0x50 | 0x08);
 				chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
 
 				strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom);
@@ -3912,7 +4043,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else if (longueur_fonction < (1LL << 16))
 			{
-				if ((chaine = malloc((3 + longueur_fonction + 1)
+				if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3920,7 +4051,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0x50 | 0x09;
+				chaine[0] = (unsigned char) (0x50 | 0x09);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
 				chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
 
@@ -3929,7 +4060,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else if (longueur_fonction < (1LL << 32))
 			{
-				if ((chaine = malloc((5 + longueur_fonction + 1)
+				if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3937,7 +4068,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x0A;
+				chaine[0] = (unsigned char) (0xE0 | 0x0A);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
 				chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
 				chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
@@ -3948,7 +4079,7 @@ formateur_fichier(struct_processus *s_et
 			}
 			else
 			{
-				if ((chaine = malloc((9 + longueur_fonction + 1)
+				if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
 						* sizeof(unsigned char)))== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3956,7 +4087,7 @@ formateur_fichier(struct_processus *s_et
 					return(NULL);
 				}
 
-				chaine[0] = 0xE0 | 0x0B;
+				chaine[0] = (unsigned char) (0xE0 | 0x0B);
 				chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
 				chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
 				chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
@@ -4051,9 +4182,10 @@ formateur_fichier(struct_processus *s_et
 
 			if (longueur_totale < (((integer8) 1) << 7))
 			{
-				tampon[0] = ((longueur_totale + 1) << 1) & 0xFF;
+				tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
+						& 0xFF);
 
-				if ((chaine = realloc(chaine, (longueur_totale + 1)
+				if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -4065,36 +4197,61 @@ formateur_fichier(struct_processus *s_et
 				memcpy(&(chaine[longueur_totale]), tampon, 1);
 				longueur_totale += 1;
 			}
-			else if (longueur_totale < (((integer8) 1) << 16))
+			else
 			{
 				longueur_totale++;
 
-				for(i = 0; i < 7; i++)
+				// i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
+
+				i = 0;
+
+				for(;;)
 				{
 					if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
 							|| (i == 6))
 					{
 						// LSB (4 bits de poids fort)
-						tampon[0] = (longueur_totale & 0xF0)
+						tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
 								| 0x1 /* longueur supérieure à 7 bits */
-								| ((i + 1) << 1);
+								| ((i + 1) << 1));
 
 						for(j = 0; j <= i; j++)
 						{
-							tampon[(i - j) + 1] =
-									(longueur_totale >> (8 * (j + 1)))
-									& 0xFF;
+							tampon[(i - j) + 1] = (unsigned char)
+									((longueur_totale >> (8 * (j + 1)))
+									& 0xFF);
 						}
 
 						// LSB (4 bits de poids faible)
-						tampon[i + 2] = ((longueur_totale & 0x0F) << 4)
+						tampon[i + 2] = (unsigned char)
+								(((longueur_totale & 0x0F) << 4)
 								| 0x1 /* longueur supérieure à 7 bits */
-								| ((i + 1) << 1);
+								| ((i + 1) << 1));
 						break;
 					}
+
+					switch(i)
+					{
+						case 0 :
+						{
+							i = 2;
+							break;
+						}
+
+						case 2 :
+						{
+							i = 6;
+							break;
+						}
+					}
 				}
 
-				if ((chaine = realloc(chaine, (longueur_totale + 3)
+				// i = 0 => +3 (16 bits)
+				// i = 2 => +5 (32 bits)
+				// i = 6 => +9 (64 bits)
+
+				if ((chaine = realloc(chaine, (((size_t) longueur_totale)
+						+ ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -4105,9 +4262,6 @@ formateur_fichier(struct_processus *s_et
 				memcpy(&(chaine[longueur_totale]), tampon, 3);
 				longueur_totale += 3;
 			}
-			else if (longueur_totale < (((integer8) 1) << 32))
-			{
-			}
 
 			__zone();
 			(*longueur_effective) = longueur_totale;
@@ -4143,7 +4297,7 @@ formateur_fichier(struct_processus *s_et
 unsigned char *
 formateur_fichier_nombre(struct_processus *s_etat_processus,
 		void *valeur_numerique, unsigned char type,
-		long longueur, long longueur_champ, unsigned char format)
+		integer8 longueur, integer8 longueur_champ, unsigned char format)
 {
 	unsigned char				*chaine;
 	unsigned char				*construction_chaine;
@@ -4283,12 +4437,13 @@ formateur_fichier_nombre(struct_processu
 unsigned char *
 formateur_fichier_reel(struct_processus *s_etat_processus,
 		void *valeur_numerique, unsigned char type,
-		long longueur, long longueur_champ,
+		integer8 longueur, integer8 longueur_champ,
 		unsigned char format_sortie)
 {
 	real8					mantisse;
 	real8					tampon_reel;
 
+	integer8				i;
 	integer8				tampon_entier;
 
 	long					correction;
@@ -4301,8 +4456,6 @@ formateur_fichier_reel(struct_processus
 	unsigned char			mode[3 + 1];
 	unsigned char			tampon[16 + 1];
 
-	unsigned long			i;
-
 	chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
 
 	if (chaine == NULL)
@@ -4328,7 +4481,7 @@ formateur_fichier_reel(struct_processus
 			exposant = 0;
 		}
 
-		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
 	}
 	else
 	{
@@ -4336,21 +4489,22 @@ formateur_fichier_reel(struct_processus
 
 		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));
+			exposant = (long) floor(log10((double) -tampon_entier));
 		}
 		else
 		{
 			exposant = 0;
 		}
 
-		mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
+				pow(10, (double) exposant);
 	}
 
-	longueur_utile = longueur;
+	longueur_utile = (long) longueur;
 	longueur_utile_limite = 15;
 
 	if (longueur_utile > longueur_utile_limite)
@@ -4411,7 +4565,7 @@ formateur_fichier_reel(struct_processus
 
 		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)
@@ -4434,7 +4588,7 @@ formateur_fichier_reel(struct_processus
 		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));
@@ -4464,7 +4618,7 @@ formateur_fichier_reel(struct_processus
 
 			sprintf(tampon, format, *((real8 *) valeur_numerique));
 
-			i = strlen(tampon) - 1;
+			i = (integer8) (strlen(tampon)) - 1;
 			while(tampon[i] == '0')
 			{
 				tampon[i] = 0;
@@ -4473,7 +4627,7 @@ formateur_fichier_reel(struct_processus
 
 			if (ds_imposition_separateur_decimal == d_faux)
 			{
-				i = strlen(tampon) - 1;
+				i = ((integer8) strlen(tampon)) - 1;
 				if (tampon[i] == '.')
 				{
 					tampon[i] = 0;
@@ -4488,7 +4642,7 @@ formateur_fichier_reel(struct_processus
 	{
 		if (strlen(chaine) > (size_t) longueur_champ)
 		{
-			for(i = 0; i < (unsigned long) longueur_champ; i++)
+			for(i = 0; i < longueur_champ; i++)
 			{
 				chaine[i] = '*';
 			}
@@ -4510,7 +4664,7 @@ formateur_fichier_reel(struct_processus
 unsigned char *
 formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
 		void *valeur_numerique, unsigned char type_entree,
-		unsigned char type, long longueur, long *longueur_conversion)
+		unsigned char type, integer8 longueur, integer8 *longueur_conversion)
 {
 	unsigned char				*chaine;
 
@@ -4544,8 +4698,9 @@ formateur_fichier_binaire_nombre(struct_
 					}
 
 					(*longueur_conversion) = 2;
-					chaine[0] = 0x10;
-					chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
+					chaine[0] = (unsigned char) 0x10;
+					chaine[1] = (unsigned char) ((*((integer8 *)
+							valeur_numerique)) & 0xFF);
 					break;
 				}
 
@@ -4567,10 +4722,11 @@ formateur_fichier_binaire_nombre(struct_
 					}
 
 					(*longueur_conversion) = 3;
-					chaine[0] = 0x11;
-					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
-							& 0xFF;
-					chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
+					chaine[0] = (unsigned char) 0x11;
+					chaine[1] = ((unsigned char) ((*((integer8 *)
+							valeur_numerique)) >> 8) & 0xFF);
+					chaine[2] = (unsigned char) ((*((integer8 *)
+							valeur_numerique)) & 0xFF);
 					break;
 				}
 
@@ -4592,14 +4748,15 @@ formateur_fichier_binaire_nombre(struct_
 					}
 
 					(*longueur_conversion) = 5;
-					chaine[0] = 0x12;
-					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
-							& 0xFF;
-					chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
-							& 0xFF;
-					chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
-							& 0xFF;
-					chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
+					chaine[0] = (unsigned char) 0x12;
+					chaine[1] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 24) & 0xFF);
+					chaine[2] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 16) & 0xFF);
+					chaine[3] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 8) & 0xFF);
+					chaine[4] = (unsigned char) ((*((integer8 *)
+							valeur_numerique)) & 0xFF);
 					break;
 				}
 
@@ -4613,22 +4770,23 @@ formateur_fichier_binaire_nombre(struct_
 					}
 
 					(*longueur_conversion) = 9;
-					chaine[0] = 0x13;
-					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
-							& 0xFF;
-					chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
-							& 0xFF;
-					chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
-							& 0xFF;
-					chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
-							& 0xFF;
-					chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
-							& 0xFF;
-					chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
-							& 0xFF;
-					chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
-							& 0xFF;
-					chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
+					chaine[0] = (unsigned char) 0x13;
+					chaine[1] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 56) & 0xFF);
+					chaine[2] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 48) & 0xFF);
+					chaine[3] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 40) & 0xFF);
+					chaine[4] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 32) & 0xFF);
+					chaine[5] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 24) & 0xFF);
+					chaine[6] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 16) & 0xFF);
+					chaine[7] = (unsigned char) (((*((integer8 *)
+							valeur_numerique)) >> 8) & 0xFF);
+					chaine[8] = (unsigned char) ((*((integer8 *)
+							valeur_numerique)) & 0xFF);
 					break;
 				}
 
@@ -4665,7 +4823,7 @@ formateur_fichier_binaire_nombre(struct_
 					}
 					else if (type_entree == 'I')
 					{
-						valeur = (*((integer8 *) valeur_numerique));
+						valeur = (real8) (*((integer8 *) valeur_numerique));
 					}
 					else
 					{
@@ -4702,11 +4860,11 @@ formateur_fichier_binaire_nombre(struct_
 
 					eq4.r4 = (real4) valeur;
 					(*longueur_conversion) = 5;
-					chaine[0] = 0x14;
-					chaine[1] = (eq4.i4 >> 24) & 0xFF;
-					chaine[2] = (eq4.i4 >> 16) & 0xFF;
-					chaine[3] = (eq4.i4 >> 8) & 0xFF;
-					chaine[4] = eq4.i4 & 0xFF;
+					chaine[0] = (unsigned char) 0x14;
+					chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF);
+					chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF);
+					chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF);
+					chaine[4] = (unsigned char) (eq4.i4 & 0xFF);
 					break;
 				}
 
@@ -4727,7 +4885,7 @@ formateur_fichier_binaire_nombre(struct_
 
 					if (type_entree == 'I')
 					{
-						eq8.r8 = (*((integer8 *) valeur_numerique));
+						eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
 					}
 					else if (type_entree == 'R')
 					{
@@ -4741,15 +4899,15 @@ formateur_fichier_binaire_nombre(struct_
 					}
 
 					(*longueur_conversion) = 9;
-					chaine[0] = 0x15;
-					chaine[1] = (eq8.i8 >> 56) & 0xFF;
-					chaine[2] = (eq8.i8 >> 48) & 0xFF;
-					chaine[3] = (eq8.i8 >> 40) & 0xFF;
-					chaine[4] = (eq8.i8 >> 32) & 0xFF;
-					chaine[5] = (eq8.i8 >> 24) & 0xFF;
-					chaine[6] = (eq8.i8 >> 16) & 0xFF;
-					chaine[7] = (eq8.i8 >> 8) & 0xFF;
-					chaine[8] = eq8.i8 & 0xFF;
+					chaine[0] = (unsigned char) (0x15);
+					chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF);
+					chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF);
+					chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF);
+					chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF);
+					chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF);
+					chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF);
+					chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF);
+					chaine[8] = (unsigned char) (eq8.i8 & 0xFF);
 					break;
 				}
 
@@ -4773,8 +4931,8 @@ formateur_fichier_binaire_nombre(struct_
 					unsigned char		*partie_reelle;
 					unsigned char		*partie_imaginaire;
 
-					long				limag;
-					long				lreel;
+					integer8			limag;
+					integer8			lreel;
 
 					real8				zero;
 
@@ -4847,8 +5005,8 @@ formateur_fichier_binaire_nombre(struct_
 						return(NULL);
 					}
 
-					if ((chaine = malloc((lreel + limag - 1) *
-							sizeof(unsigned char))) == NULL)
+					if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
+							- 1) * sizeof(unsigned char))) == NULL)
 					{
 						free(partie_reelle);
 						free(partie_imaginaire);
@@ -4858,9 +5016,11 @@ formateur_fichier_binaire_nombre(struct_
 						return(NULL);
 					}
 
-					chaine[0] = 0x18;
-					memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
-					memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
+					chaine[0] = (unsigned char) 0x18;
+					memcpy(chaine + 1, partie_reelle + 1,
+							((size_t) lreel) - 1);
+					memcpy(chaine + lreel, partie_imaginaire + 1,
+							((size_t) limag) - 1);
 					(*longueur_conversion) = lreel + limag - 1;
 
 					free(partie_reelle);
@@ -4873,8 +5033,9 @@ formateur_fichier_binaire_nombre(struct_
 					unsigned char		*partie_reelle;
 					unsigned char		*partie_imaginaire;
 
-					long				limag;
-					long				lreel;
+					integer8			limag;
+					integer8			lreel;
+
 					real8				zero;
 
 					if (type_entree == 'I')
@@ -4946,8 +5107,8 @@ formateur_fichier_binaire_nombre(struct_
 						return(NULL);
 					}
 
-					if ((chaine = malloc((lreel + limag - 1) *
-							sizeof(unsigned char))) == NULL)
+					if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
+							- 1) * sizeof(unsigned char))) == NULL)
 					{
 						free(partie_reelle);
 						free(partie_imaginaire);
@@ -4957,9 +5118,11 @@ formateur_fichier_binaire_nombre(struct_
 						return(NULL);
 					}
 
-					chaine[0] = 0x19;
-					memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
-					memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
+					chaine[0] = (unsigned char) 0x19;
+					memcpy(chaine + 1, partie_reelle + 1,
+							((size_t) lreel) - 1);
+					memcpy(chaine + lreel, partie_imaginaire + 1,
+							((size_t) limag) - 1);
 					(*longueur_conversion) = lreel + limag - 1;
 
 					free(partie_reelle);
@@ -5154,7 +5317,7 @@ lecture_fichier_non_formate(struct_proce
 			for(i = 0; i < (signed) deplacement; i++)
 			{
 				(*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
-						<< (8 * ((deplacement - 1) - i));
+						<< (8 * ((((signed) deplacement) - 1) - i));
 			}
 
 			break;
@@ -5234,13 +5397,69 @@ lecture_fichier_non_formate(struct_proce
 						return(NULL);
 					}
 
-					(*((integer8 *) (*s_objet).objet)) = 0;
+					// Récupération des données avec extension de signe.
 
-					for(i = 0; i < (signed) deplacement; i++)
 					{
-						(*((integer8 *) (*s_objet).objet)) |=
-								((integer8) octets[i])
-								<< (8 * ((deplacement - 1) - i));
+						integer1		i1;
+						integer2		i2;
+						integer4		i4;
+						integer8		i8;
+
+						i1 = 0;
+						i2 = 0;
+						i4 = 0;
+						i8 = 0;
+
+						for(i = 0; i < (signed) deplacement; i++)
+						{
+							switch(deplacement)
+							{
+								case 1:
+									i1 = (integer1) octets[0];
+								break;
+
+								case 2:
+									i2 |= (integer2) (((integer8) octets[i]) <<
+											(8 * ((((signed) deplacement) - 1)
+											- i)));
+								break;
+
+								case 4:
+									i4 |= (integer4) (((integer8) octets[i]) <<
+											(8 * ((((signed) deplacement) - 1)
+											- i)));
+								break;
+
+								case 8:
+									i8 |= (integer8) (((integer8) octets[i]) <<
+											(8 * ((((signed) deplacement) - 1)
+											- i)));
+								break;
+							}
+						}
+
+						switch(deplacement)
+						{
+							case 1:
+								(*((integer8 *) (*s_objet).objet)) =
+										(integer8) i1;
+							break;
+
+							case 2:
+								(*((integer8 *) (*s_objet).objet)) =
+										(integer8) i2;
+							break;
+
+							case 4:
+								(*((integer8 *) (*s_objet).objet)) =
+										(integer8) i4;
+							break;
+
+							case 8:
+								(*((integer8 *) (*s_objet).objet)) =
+										(integer8) i8;
+							break;
+						}
 					}
 
 					break;
@@ -5325,7 +5544,7 @@ lecture_fichier_non_formate(struct_proce
 						for(i = 0; i < (signed) deplacement; i++)
 						{
 							eq4.i4 |= ((integer4) octets[i]) <<
-									(8 * ((deplacement - 1) - i));
+									(8 * ((((signed) deplacement) - 1) - i));
 						}
 
 						(*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
@@ -5343,7 +5562,7 @@ lecture_fichier_non_formate(struct_proce
 						for(i = 0; i < (signed) deplacement; i++)
 						{
 							eq8.i8 |= ((integer8) octets[i]) <<
-									(8 * ((deplacement - 1) - i));
+									(8 * ((((signed) deplacement) - 1) - i));
 						}
 
 						(*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
@@ -5436,7 +5655,8 @@ lecture_fichier_non_formate(struct_proce
 							for(i = 0; i < (signed) deplacement; i++)
 							{
 								eq4.i4 |= ((integer4) octets[i]) <<
-										(8 * ((deplacement - 1) - i));
+										(8 * ((((signed) deplacement) - 1)
+										- i));
 							}
 
 							if (j == 0)
@@ -5463,7 +5683,8 @@ lecture_fichier_non_formate(struct_proce
 							for(i = 0; i < (signed) deplacement; i++)
 							{
 								eq8.i8 |= ((integer8) octets[i]) <<
-										(8 * ((deplacement - 1) - i));
+										(8 * ((((signed) deplacement) - 1)
+										- i));
 							}
 
 							if (j == 0)
@@ -5947,7 +6168,8 @@ lecture_fichier_non_formate(struct_proce
 
 			if (longueur_buffer < 0)
 			{
-				if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL)
+				if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
+						== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -5955,7 +6177,7 @@ lecture_fichier_non_formate(struct_proce
 				}
 
 				if (fread(flux, (size_t) sizeof(unsigned char),
-						longueur, fichier) != (size_t) longueur)
+						(size_t) longueur, fichier) != (size_t) longueur)
 				{
 					if (feof(fichier))
 					{
@@ -6200,7 +6422,8 @@ lecture_fichier_non_formate(struct_proce
 			}
 
 			if (((*((struct_nom *) (*s_objet).objet)).nom =
-					malloc((longueur + 1) * sizeof(unsigned char))) == NULL)
+					malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -6210,7 +6433,7 @@ lecture_fichier_non_formate(struct_proce
 			{
 				if (fread((unsigned char *) (*((struct_nom *) (*s_objet)
 						.objet)).nom, (size_t) sizeof(unsigned char),
-						longueur, fichier) != (unsigned) longueur)
+						(size_t) longueur, fichier) != (unsigned) longueur)
 				{
 					if (feof(fichier))
 					{
@@ -6460,7 +6683,8 @@ lecture_fichier_non_formate(struct_proce
 			}
 
 			if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
-					malloc((longueur + 1) * sizeof(unsigned char))) == NULL)
+					malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -6470,7 +6694,7 @@ lecture_fichier_non_formate(struct_proce
 			{
 				if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
 						.objet)).nom_fonction, (size_t) sizeof(unsigned char),
-						longueur, fichier) != (unsigned) longueur)
+						(size_t) longueur, fichier) != (unsigned) longueur)
 				{
 					if (feof(fichier))
 					{
@@ -6565,7 +6789,7 @@ lecture_fichier_non_formate(struct_proce
 
 		if ((octets[0] & 0x01) != 0)
 		{
-			deplacement = ((octets[0] & 0x0F) >> 1) + 1;
+			deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);
 
 			if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
 					fichier) != deplacement)