--- rpl/src/formateur_fichiers.c	2013/03/16 20:11:29	1.56
+++ rpl/src/formateur_fichiers.c	2013/04/18 15:44:39	1.70
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
+  RPL/2 (R) version 4.1.14
   Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -19,6 +19,7 @@
 ================================================================================
 */
 
+
 #define DEBUG_ERREURS
 #include "rpl-conv.h"
 
@@ -40,9 +41,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,8 +80,6 @@ formateur_fichier(struct_processus *s_et
 	logical1					format_degenere;
 	logical1					presence_signe;
 
-	long						longueur_chaine_traitee;
-
 	struct_liste_chainee		*l_atome;
 	struct_liste_chainee		*l_element_courant;
 	struct_liste_chainee		*l_element_courant_format;
@@ -103,14 +103,16 @@ 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;
 	integer8					longueur_totale;
@@ -927,8 +929,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;
 
@@ -990,7 +992,7 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
-			if ((format_sortie != 'B') && (format_sortie != 'U'))
+			if ((format_sortie != 'B') && (format_sortie != 'N'))
 			{
 				(*s_etat_processus).erreur_execution =
 						d_ex_erreur_format_fichier;
@@ -999,7 +1001,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");
 			}
@@ -1009,8 +1011,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));
@@ -1025,7 +1027,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])
 							{
@@ -1119,7 +1121,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;
@@ -1127,7 +1129,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;
@@ -1135,8 +1137,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;
 					}
@@ -1155,7 +1157,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
@@ -1190,7 +1193,7 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
-			if ((format_sortie != 'C') && (format_sortie != 'U'))
+			if ((format_sortie != 'C') && (format_sortie != 'N'))
 			{
 				(*s_etat_processus).erreur_execution =
 						d_ex_erreur_format_fichier;
@@ -1227,7 +1230,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 =
@@ -1236,7 +1239,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;
 			}
 		}
@@ -1587,7 +1590,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] != ')')
 					{
@@ -1622,7 +1625,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);
@@ -1640,7 +1643,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);
@@ -1935,7 +1938,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;
@@ -1959,7 +1962,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);
@@ -1977,7 +1980,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);
@@ -2873,7 +2876,7 @@ formateur_fichier(struct_processus *s_et
 			return(NULL);
 		}
 
-		(*longueur_effective) = strlen(chaine) + 1;
+		(*longueur_effective) = ((integer8) strlen(chaine)) + 1;
 	}
 	else
 	{
@@ -3031,6 +3034,9 @@ formateur_fichier(struct_processus *s_et
 		 * 1101 10 11				matrice complex*16 (dimensions integer*4)
 		 * 1101 11 11				matrice complex*16 (dimensions integer*8)
 		 *
+		 * 1110 0 XXX				fonction de longueur XXX
+		 * 1110 10 LL				fonction de longueur integer*LL
+		 *
 		 * Les longueurs indiquées par le champ LL suivent l'en-tête :
 		 * 		00 : integer*1
 		 * 		01 : integer*2
@@ -3057,6 +3063,12 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'L';
+				longueur_champ = 8;
+			}
+
 			if (format_sortie != 'L')
 			{
 				(*s_etat_processus).erreur_execution =
@@ -3077,16 +3089,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;
@@ -3103,6 +3115,19 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+				longueur_champ = -1;
+			}
+
+			if (format_sortie != 'S')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
 			longueur_reelle_chaine = longueur_chaine(s_etat_processus,
 					(unsigned char *) (*s_objet).objet);
 
@@ -3129,15 +3154,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);
 			}
@@ -3146,7 +3171,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 =
@@ -3154,14 +3179,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 =
@@ -3169,15 +3196,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 =
@@ -3185,17 +3213,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 =
@@ -3203,7 +3232,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)
@@ -3212,12 +3241,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 =
@@ -3225,7 +3255,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)
@@ -3242,7 +3272,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;
 			}
 
@@ -3258,6 +3289,12 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'C';
+				longueur = 8;
+			}
+
 			if (format_sortie != 'C')
 			{
 				(*s_etat_processus).erreur_execution =
@@ -3282,6 +3319,12 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'I';
+				longueur = 8;
+			}
+
 			if ((format_sortie != 'I') && (format_sortie != 'R')
 					&& (format_sortie != 'C'))
 			{
@@ -3303,9 +3346,122 @@ formateur_fichier(struct_processus *s_et
 /*
 --------------------------------------------------------------------------------
   Fonction
+  Poids fort 1110
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_fonction = (integer8) strlen((*((struct_fonction *)
+					(*s_objet).objet)).nom_fonction);
+
+			if (longueur_fonction < (1LL << 3))
+			{
+				if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
+
+				strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+				(*longueur_effective) = 1 + longueur_fonction + 8;
+			}
+			else if (longueur_fonction < (1LL << 8))
+			{
+				if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = (unsigned char) (0xE0 | 0x08);
+				chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+				(*longueur_effective) = 2 + longueur_fonction + 8;
+			}
+			else if (longueur_fonction < (1LL << 16))
+			{
+				if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = (unsigned char ) (0xE0 | 0x09);
+				chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+				(*longueur_effective) = 3 + longueur_fonction + 9;
+			}
+			else if (longueur_fonction < (1LL << 32))
+			{
+				if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				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);
+				chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+				(*longueur_effective) = 5 + longueur_fonction + 8;
+			}
+			else
+			{
+				if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				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);
+				chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+				(*longueur_effective) = 9 + longueur_fonction + 8;
+			}
+
+			for(i = 1; i <= 8; i++)
+			{
+				chaine[(*longueur_effective) - i] = (unsigned char)
+						(((*((struct_fonction *) (*s_objet).objet))
+						.nombre_arguments >> ((8 - i) * 8)) & 0xFF);
+			}
 		}
 		else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
 				|| ((*s_objet).type == RPN))
@@ -3358,23 +3514,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;
@@ -3387,7 +3544,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 =
@@ -3404,7 +3562,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 =
@@ -3423,7 +3582,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 =
@@ -3446,7 +3606,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 =
@@ -3493,17 +3654,33 @@ formateur_fichier(struct_processus *s_et
 						(((*(*l_element_courant_format).donnee).type == TBL)
 						&& ((*(*l_element_courant).donnee).type == TBL)))
 				{
-					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*l_element_courant).donnee,
-							(*l_element_courant_format).donnee, 0, 0, ' ', 'U',
-							longueur_effective, recursivite, export_fichier))
-							== NULL)
+					if (format_sortie != 'N')
 					{
-						return(NULL);
+						if ((chaine_formatee = formateur_fichier(
+								s_etat_processus,
+								(*l_element_courant).donnee,
+								(*l_element_courant_format).donnee,
+								0, 0, ' ', 'U', longueur_effective, recursivite,
+								export_fichier)) == NULL)
+						{
+							return(NULL);
+						}
+					}
+					else
+					{
+						if ((chaine_formatee = formateur_fichier(
+								s_etat_processus,
+								(*l_element_courant).donnee,
+								(*l_element_courant_format).donnee,
+								0, 0, 'N', 'U', longueur_effective, recursivite,
+								export_fichier)) == NULL)
+						{
+							return(NULL);
+						}
 					}
 
-					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 =
@@ -3512,7 +3689,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);
 				}
@@ -3561,6 +3738,12 @@ formateur_fichier(struct_processus *s_et
 						position_1 = 10;
 						format_degenere = d_vrai;
 					}
+					else if (strcmp("NATIVE*(*)", format_chaine) == 0)
+					{
+						format_sortie = 'N';
+						position_1 = 7;
+						format_degenere = d_vrai;
+					}
 					else
 					{
 						free(chaine);
@@ -3583,7 +3766,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);
@@ -3615,7 +3798,7 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					if ((chaine = realloc(chaine,
-							(longueur_totale + (*longueur_effective))
+							((size_t) (longueur_totale + (*longueur_effective)))
 							* sizeof(unsigned char))) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -3624,24 +3807,32 @@ 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;
-				l_element_courant_format = (*l_element_courant_format).suivant;
+
+				if (format_sortie != 'N')
+				{
+					l_element_courant_format =
+							(*l_element_courant_format).suivant;
+				}
 			}
 
-			if ((l_element_courant != NULL) ||
-					(l_element_courant_format != NULL))
+			if (format_sortie != 'N')
 			{
-				free(chaine);
+				if ((l_element_courant != NULL) ||
+						(l_element_courant_format != NULL))
+				{
+					free(chaine);
 
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_format_fichier;
-				return(NULL);
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_format_fichier;
+					return(NULL);
+				}
 			}
 
 			(*longueur_effective) = longueur_totale;
@@ -3688,8 +3879,112 @@ formateur_fichier(struct_processus *s_et
 /*
 --------------------------------------------------------------------------------
   Nom
+  Poids fort 0101
 --------------------------------------------------------------------------------
 */
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_fonction = (integer8) strlen((*((struct_nom *)
+					(*s_objet).objet)).nom);
+
+			if (longueur_fonction < (1LL << 3))
+			{
+				if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				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 + ((size_t) longueur_fonction) + 1)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = (unsigned char) (0x50 | 0x08);
+				chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom);
+				(*longueur_effective) = longueur_fonction + 3;
+			}
+			else if (longueur_fonction < (1LL << 16))
+			{
+				if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = (unsigned char) (0x50 | 0x09);
+				chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom);
+				(*longueur_effective) = longueur_fonction + 4;
+			}
+			else if (longueur_fonction < (1LL << 32))
+			{
+				if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				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);
+				chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 5, (*((struct_nom *) (*s_objet).objet)).nom);
+				(*longueur_effective) = longueur_fonction + 6;
+			}
+			else
+			{
+				if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				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);
+				chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 9, (*((struct_nom *) (*s_objet).objet)).nom);
+				(*longueur_effective) = longueur_fonction + 10;
+			}
+
+			chaine[(*longueur_effective) - 1] = ((*((struct_nom *)
+					(*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00;
 		}
 		else if ((*s_objet).type == REL)
 		{
@@ -3701,6 +3996,12 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'R';
+				longueur = 8;
+			}
+
 			if ((format_sortie != 'R') && (format_sortie != 'C'))
 			{
 				(*s_etat_processus).erreur_execution =
@@ -3763,9 +4064,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 =
@@ -3777,36 +4079,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 =
@@ -3817,9 +4144,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;
@@ -3855,7 +4179,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;
@@ -3995,12 +4319,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;
@@ -4013,8 +4338,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)
@@ -4040,7 +4363,7 @@ formateur_fichier_reel(struct_processus
 			exposant = 0;
 		}
 
-		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
 	}
 	else
 	{
@@ -4048,21 +4371,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)
@@ -4123,7 +4447,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)
@@ -4146,7 +4470,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));
@@ -4176,7 +4500,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;
@@ -4185,7 +4509,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;
@@ -4200,7 +4524,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] = '*';
 			}
@@ -4222,7 +4546,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;
 
@@ -4256,8 +4580,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;
 				}
 
@@ -4279,10 +4604,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;
 				}
 
@@ -4304,14 +4630,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;
 				}
 
@@ -4325,22 +4652,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;
 				}
 
@@ -4377,7 +4705,7 @@ formateur_fichier_binaire_nombre(struct_
 					}
 					else if (type_entree == 'I')
 					{
-						valeur = (*((integer8 *) valeur_numerique));
+						valeur = (real8) (*((integer8 *) valeur_numerique));
 					}
 					else
 					{
@@ -4414,11 +4742,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;
 				}
 
@@ -4439,7 +4767,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')
 					{
@@ -4453,15 +4781,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;
 				}
 
@@ -4485,8 +4813,8 @@ formateur_fichier_binaire_nombre(struct_
 					unsigned char		*partie_reelle;
 					unsigned char		*partie_imaginaire;
 
-					long				limag;
-					long				lreel;
+					integer8			limag;
+					integer8			lreel;
 
 					real8				zero;
 
@@ -4559,8 +4887,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);
@@ -4570,9 +4898,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);
@@ -4585,8 +4915,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')
@@ -4658,8 +4989,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);
@@ -4669,9 +5000,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);
@@ -4735,6 +5068,7 @@ lecture_fichier_non_formate(struct_proce
 	unsigned char				*buffer;
 	unsigned char				*flux;
 	unsigned char				*ptr;
+	unsigned char				type_objet;
 
 	size_t						deplacement;
 
@@ -4781,7 +5115,7 @@ lecture_fichier_non_formate(struct_proce
 		}
 	}
 
-	switch(octets[0] & 0xF0)
+	switch(type_objet = (octets[0] & 0xF0))
 	{
 		case 0x00:	// Binaire
 		{
@@ -4865,7 +5199,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;
@@ -4945,13 +5279,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;
@@ -5036,7 +5426,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;
@@ -5054,7 +5444,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;
@@ -5147,7 +5537,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)
@@ -5174,7 +5565,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)
@@ -5204,6 +5596,8 @@ lecture_fichier_non_formate(struct_proce
 		}
 
 		case 0x40:	// Liste
+		case 0x60:	// Expression
+		case 0x70:	// Expression algébrique
 		{
 			if ((octets[0] & 0x08) == 0)	// Longueur sur 6 bits
 			{
@@ -5388,9 +5782,26 @@ lecture_fichier_non_formate(struct_proce
 				}
 			}
 
-			if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
+			if (type_objet == 0x40)
 			{
-				return(NULL);
+				if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
+				{
+					return(NULL);
+				}
+			}
+			else if (type_objet == 0x60)
+			{
+				if ((s_objet = allocation(s_etat_processus, RPN)) == NULL)
+				{
+					return(NULL);
+				}
+			}
+			else
+			{
+				if ((s_objet = allocation(s_etat_processus, ALG)) == NULL)
+				{
+					return(NULL);
+				}
 			}
 
 			l_element_courant = NULL;
@@ -5639,7 +6050,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;
@@ -5647,7 +6059,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))
 					{
@@ -5700,6 +6112,535 @@ lecture_fichier_non_formate(struct_proce
 			break;
 		}
 
+		case 0x50:	// Nom
+		{
+			if ((octets[0] & 0x08) == 0)	// Longueur sur 6 bits
+			{
+				longueur = (octets[0] & 0x07);
+			}
+			else
+			{
+				switch(octets[0] & 0x07)
+				{
+					case 0x00:			// Longueur sur 8 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									1, fichier) != 1)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 1)
+							{
+								octets[0] = *ptr++;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = octets[0];
+						break;
+					}
+
+					case 0x01:			// Longueur sur 16 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									2, fichier) != 2)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 2)
+							{
+								for(j = 0; j < 2; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 8)
+								| ((integer8) (octets[1]));
+						break;
+					}
+
+					case 0x02:			// Longueur sur 32 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									4, fichier) != 4)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 4)
+							{
+								for(j = 0; j < 4; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 24)
+								| (((integer8) (octets[1])) << 16)
+								| (((integer8) (octets[2])) << 8)
+								| ((integer8) (octets[3]));
+						break;
+					}
+
+					case 0x03:			// Longueur sur 64 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									8, fichier) != 8)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 8)
+							{
+								for(j = 0; j < 8; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 56)
+								| (((integer8) (octets[1])) << 48)
+								| (((integer8) (octets[2])) << 40)
+								| (((integer8) (octets[3])) << 32)
+								| (((integer8) (octets[4])) << 24)
+								| (((integer8) (octets[5])) << 16)
+								| (((integer8) (octets[6])) << 8)
+								| ((integer8) (octets[7]));
+						break;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+						return(NULL);
+					}
+				}
+			}
+
+			if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (((*((struct_nom *) (*s_objet).objet)).nom =
+					malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (longueur_buffer < 0)
+			{
+				if (fread((unsigned char *) (*((struct_nom *) (*s_objet)
+						.objet)).nom, (size_t) sizeof(unsigned char),
+						(size_t) longueur, fichier) != (unsigned) longueur)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+
+				if (fread(octets, (size_t) sizeof(unsigned char),
+						1, fichier) != 1)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+			}
+			else
+			{
+				if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1))
+				{
+					for(j = 0; j < longueur; (*((struct_nom *)
+							(*s_objet).objet)).nom[j] = *ptr++);
+					octets[0] = *ptr++;
+				}
+				else
+				{
+					liberation(s_etat_processus, s_objet);
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					return(NULL);
+				}
+			}
+
+			(*((struct_nom *) (*s_objet).objet)).nom[longueur] =
+					d_code_fin_chaine;
+			(*((struct_nom *) (*s_objet).objet)).symbole =
+					(octets[0] == 0xFF) ? d_vrai : d_faux;
+			break;
+		}
+
+		case 0xE0:	// Fonction
+		{
+			if ((octets[0] & 0x08) == 0)	// Longueur sur 6 bits
+			{
+				longueur = (octets[0] & 0x07);
+			}
+			else
+			{
+				switch(octets[0] & 0x07)
+				{
+					case 0x00:			// Longueur sur 8 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									1, fichier) != 1)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 1)
+							{
+								octets[0] = *ptr++;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = octets[0];
+						break;
+					}
+
+					case 0x01:			// Longueur sur 16 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									2, fichier) != 2)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 2)
+							{
+								for(j = 0; j < 2; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 8)
+								| ((integer8) (octets[1]));
+						break;
+					}
+
+					case 0x02:			// Longueur sur 32 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									4, fichier) != 4)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 4)
+							{
+								for(j = 0; j < 4; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 24)
+								| (((integer8) (octets[1])) << 16)
+								| (((integer8) (octets[2])) << 8)
+								| ((integer8) (octets[3]));
+						break;
+					}
+
+					case 0x03:			// Longueur sur 64 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									8, fichier) != 8)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 8)
+							{
+								for(j = 0; j < 8; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 56)
+								| (((integer8) (octets[1])) << 48)
+								| (((integer8) (octets[2])) << 40)
+								| (((integer8) (octets[3])) << 32)
+								| (((integer8) (octets[4])) << 24)
+								| (((integer8) (octets[5])) << 16)
+								| (((integer8) (octets[6])) << 8)
+								| ((integer8) (octets[7]));
+						break;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+						return(NULL);
+					}
+				}
+			}
+
+			if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
+					malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (longueur_buffer < 0)
+			{
+				if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
+						.objet)).nom_fonction, (size_t) sizeof(unsigned char),
+						(size_t) longueur, fichier) != (unsigned) longueur)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+
+				if (fread(octets, (size_t) sizeof(unsigned char),
+						8, fichier) != 8)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+			}
+			else
+			{
+				if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
+				{
+					for(j = 0; j < longueur; (*((struct_fonction *)
+							(*s_objet).objet)).nom_fonction[j] = *ptr++);
+					for(j = 0; j < 8; octets[j++] = *ptr++);
+				}
+				else
+				{
+					liberation(s_etat_processus, s_objet);
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					return(NULL);
+				}
+			}
+
+			(*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
+					d_code_fin_chaine;
+			(*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
+					(((integer8) (octets[0])) << 56)
+					| (((integer8) (octets[1])) << 48)
+					| (((integer8) (octets[2])) << 40)
+					| (((integer8) (octets[3])) << 32)
+					| (((integer8) (octets[4])) << 24)
+					| (((integer8) (octets[5])) << 16)
+					| (((integer8) (octets[6])) << 8)
+					| ((integer8) (octets[7]));
+			break;
+		}
+
 		default:
 		{
 			(*s_etat_processus).erreur_execution = d_ex_syntaxe;
@@ -5730,7 +6671,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)