--- rpl/src/formateur_fichiers.c	2013/03/15 11:37:25	1.55
+++ rpl/src/formateur_fichiers.c	2014/04/25 07:37:29	1.77
@@ -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.18
+  Copyright (C) 1989-2014 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 :
@@ -62,7 +63,8 @@ formateur_fichier(struct_processus *s_et
 	 *   "binary*X(*)"
 	 *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
 	 *   "character*(*)"
-	 *   "character*(Y)" }
+	 *   "character*(Y)"
+	 *   "native*(*)" }
 	 *
 	 * Traitement du format des fichiers non formatés :
 	 *
@@ -70,21 +72,20 @@ formateur_fichier(struct_processus *s_et
 	 *   "real*4", "real*8", ["real*16",]
 	 *   "complex*8", "complex*16", ["complex*32",]
 	 *   "logical*1", "logical*2", "logical*4", logical*8",
-	 *   "character*n" "character*(*)" }
+	 *   "character*n" "character*(*)" "native*(*)" }
 	 */
 
 	logical1					autorisation_parenthese;
 	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;
 	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;
@@ -102,18 +103,19 @@ 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;
-	integer8					masque_binaire;
 	integer8					position_1;
 	integer8					position_2;
 	integer8					position_3;
@@ -132,8 +134,6 @@ formateur_fichier(struct_processus *s_et
 
 		strcpy(base, " ");
 
-		masque_binaire = 0;
-
 		if ((*s_objet).type == ALG)
 		{
 
@@ -143,6 +143,13 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
 			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
 
 			while(l_element_courant != NULL)
@@ -922,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;
 
@@ -985,157 +992,181 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
-			if (format_sortie != 'B')
+			if ((format_sortie != 'B') && (format_sortie != 'N'))
 			{
 				(*s_etat_processus).erreur_execution =
 						d_ex_erreur_format_fichier;
 				return(NULL);
 			}
 
-			masque_binaire = masque_entiers_binaires(s_etat_processus);
-
-			if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
-					(test_cfsf(s_etat_processus, 44) == d_faux))
+			if (format_sortie == 'N')
 			{
-
-/*
--- Base décimale ---------------------------------------------------------------
-*/
-
-				sprintf(tampon, "%llu", (*((logical8 *)
-						((*s_objet).objet))) & masque_binaire);
-				strcpy(base, "d");
+				sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
+						((*s_objet).objet))));
+				strcpy(base, "h");
 			}
-			else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
-					(test_cfsf(s_etat_processus, 44) == d_faux))
+			else
 			{
+				switch(longueur)
+				{
+					case 2:
+					{
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
 
-/*
--- Base octale -----------------------------------------------------------------
-*/
+						chaine = (unsigned char *) malloc((strlen(tampon) + 1)
+								* sizeof(unsigned char));
 
-				sprintf(tampon, "%llo", (*((logical8 *)
-						((*s_objet).objet))) & masque_binaire);
-				strcpy(base, "o");
-			}
-			else if (test_cfsf(s_etat_processus, 44) == d_vrai)
-			{
+						if (chaine == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
 
-/*
--- Bases hexadécimale et binaire -----------------------------------------------
-*/
+						strcpy(chaine, tampon);
+						tampon[0] = 0;
 
-				sprintf(tampon, "%llX", (*((logical8 *)
-						((*s_objet).objet))) & masque_binaire);
+						for(i = 0; i < ((integer8) strlen(chaine)); i++)
+						{
+							switch(chaine[i])
+							{
+								case '0' :
+								{
+									strcat(tampon, (i != 0) ? "0000" : "0");
+									break;
+								}
+								case '1' :
+								{
+									strcat(tampon, (i != 0) ? "0001" : "1");
+									break;
+								}
+								case '2' :
+								{
+									strcat(tampon, (i != 0) ? "0010" : "10");
+									break;
+								}
+								case '3' :
+								{
+									strcat(tampon, (i != 0) ? "0011" : "11");
+								break;
+								}
+								case '4' :
+								{
+									strcat(tampon, (i != 0) ? "0100" : "100");
+									break;
+								}
+								case '5' :
+								{
+									strcat(tampon, (i != 0) ? "0101" : "101");
+									break;
+								}
+								case '6' :
+								{
+									strcat(tampon, (i != 0) ? "0110" : "110");
+									break;
+								}
+								case '7' :
+								{
+									strcat(tampon, (i != 0) ? "0111" : "111");
+									break;
+								}
+								case '8' :
+								{
+									strcat(tampon, "1000");
+									break;
+								}
+								case '9' :
+								{
+									strcat(tampon, "1001");
+									break;
+								}
+								case 'A' :
+								{
+									strcat(tampon, "1010");
+									break;
+								}
+								case 'B' :
+								{
+									strcat(tampon, "1011");
+									break;
+								}
+								case 'C' :
+								{
+									strcat(tampon, "1100");
+									break;
+								}
+								case 'D' :
+								{
+									strcat(tampon, "1101");
+									break;
+								}
+								case 'E' :
+								{
+									strcat(tampon, "1110");
+									break;
+								}
+								case 'F' :
+								{
+									strcat(tampon, "1111");
+									break;
+								}
+							}
+						}
 
-				if (test_cfsf(s_etat_processus, 43) == d_vrai)
-				{
-					strcpy(base, "h");
-				}
-				else
-				{
-					chaine = (unsigned char *) malloc((strlen(tampon) + 1)
-							* sizeof(unsigned char));
+						free(chaine);
+						strcpy(base, "b");
+						break;
+					}
 
-					if (chaine == NULL)
+					case 8:
 					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						return(NULL);
+						sprintf(tampon, "%llo", (*((unsigned long long *)
+								((*s_objet).objet))));
+						strcpy(base, "o");
+						break;
 					}
 
-					strcpy(chaine, tampon);
-					tampon[0] = 0;
+					case 10:
+					{
+						sprintf(tampon, "%llu", (*((unsigned long long *)
+								((*s_objet).objet))));
+						strcpy(base, "d");
+						break;
+					}
 
-					for(i = 0; i < strlen(chaine); i++)
+					case 16:
 					{
-						switch(chaine[i])
-						{
-							case '0' :
-							{
-								strcat(tampon, (i != 0) ? "0000" : "0");
-								break;
-							}
-							case '1' :
-							{
-									strcat(tampon, (i != 0) ? "0001" : "1");
-								break;
-							}
-							case '2' :
-							{
-								strcat(tampon, (i != 0) ? "0010" : "10");
-								break;
-							}
-							case '3' :
-							{
-								strcat(tampon, (i != 0) ? "0011" : "11");
-								break;
-							}
-							case '4' :
-							{
-								strcat(tampon, (i != 0) ? "0100" : "100");
-								break;
-							}
-							case '5' :
-							{
-								strcat(tampon, (i != 0) ? "0101" : "101");
-								break;
-							}
-							case '6' :
-							{
-								strcat(tampon, (i != 0) ? "0110" : "110");
-								break;
-							}
-							case '7' :
-							{
-								strcat(tampon, (i != 0) ? "0111" : "111");
-								break;
-							}
-							case '8' :
-							{
-								strcat(tampon, "1000");
-								break;
-							}
-							case '9' :
-							{
-								strcat(tampon, "1001");
-								break;
-							}
-							case 'A' :
-							{
-								strcat(tampon, "1010");
-								break;
-							}
-							case 'B' :
-							{
-								strcat(tampon, "1011");
-								break;
-							}
-							case 'C' :
-							{
-								strcat(tampon, "1100");
-								break;
-							}
-							case 'D' :
-							{
-								strcat(tampon, "1101");
-								break;
-							}
-							case 'E' :
-							{
-								strcat(tampon, "1110");
-								break;
-							}
-							case 'F' :
-							{
-								strcat(tampon, "1111");
-								break;
-							}
-						}
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
+						strcpy(base, "h");
+						break;
 					}
 
-					free(chaine);
-					strcpy(base, "b");
+					default:
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_format_fichier;
+						return(NULL);
+					}
+				}
+			}
+
+			if (format_sortie == 'B')
+			{
+				if ((longueur_champ > 0) && (longueur_champ
+						< (signed) strlen(tampon)))
+				{
+					ptrl = &(tampon[((integer8) strlen(tampon))
+							- longueur_champ]);
+					ptre = tampon;
+
+					do
+					{
+						*ptre++ = *ptrl++;
+					} while((*ptrl) != d_code_fin_chaine);
+
+					(*ptre) = d_code_fin_chaine;
 				}
 			}
 
@@ -1162,7 +1193,7 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
-			if (format_sortie != 'C')
+			if ((format_sortie != 'C') && (format_sortie != 'N'))
 			{
 				(*s_etat_processus).erreur_execution =
 						d_ex_erreur_format_fichier;
@@ -1172,6 +1203,11 @@ formateur_fichier(struct_processus *s_et
 			longueur_reelle_chaine = longueur_chaine(s_etat_processus,
 					(unsigned char *) (*s_objet).objet);
 
+			if (format_sortie == 'N')
+			{
+				longueur_champ = -1;
+			}
+
 			if ((longueur_champ == -1) || (longueur_reelle_chaine <
 					longueur_champ))
 			{
@@ -1194,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 =
@@ -1203,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;
 			}
 		}
@@ -1216,6 +1252,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -1253,6 +1294,13 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
 			l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
 			chaine_sauvegarde = chaine;
 
@@ -1335,6 +1383,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -1372,6 +1425,13 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
 			chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
 					((*s_objet).objet))).nom_fonction) + 1) *
 					sizeof(unsigned char));
@@ -1419,13 +1479,29 @@ formateur_fichier(struct_processus *s_et
 				{
 					chaine_sauvegarde = chaine;
 
-					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*l_element_courant).donnee,
-							(*l_element_courant_format).donnee,
-							0, 0, ' ', 'F', 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, ' ', 'F', 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', 'F', longueur_effective, recursivite,
+								export_fichier)) == NULL)
+						{
+							return(NULL);
+						}
 					}
 
 					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
@@ -1498,6 +1574,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);
@@ -1508,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] != ')')
 					{
@@ -1543,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);
@@ -1561,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);
@@ -1578,7 +1660,7 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
-							longueur_champ))
+							longueur_champ) && (format_sortie != 'B'))
 					{
 						free(chaine);
 						free(format_chaine);
@@ -1592,16 +1674,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 *)
@@ -1665,17 +1801,29 @@ formateur_fichier(struct_processus *s_et
 
 				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))
+			// Dans le cas où le format de sortie n'est pas du type
+			// NATIVE*(*), on vérifie que tous les éléments du format et
+			// de la liste d'arguments ont été consommés.
+
+			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);
+				}
 			}
 
 			chaine_sauvegarde = chaine;
@@ -1701,23 +1849,23 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
-			if ((*s_format).type != TBL)
+			if (((*s_format).type != TBL) && (format_sortie != 'N'))
 			{
 				(*s_etat_processus).erreur_execution =
 						d_ex_erreur_format_fichier;
 				return(NULL);
 			}
 
-			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
-			l_element_courant_format = (struct_liste_chainee *)
-					(*s_format).objet;
-
-			if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
-					(*((struct_tableau *) (*s_format).objet)).nombre_elements)
+			if (format_sortie != 'N')
 			{
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_format_fichier;
-				return(NULL);
+				if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
+						(*((struct_tableau *) (*s_format).objet))
+						.nombre_elements)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_format_fichier;
+					return(NULL);
+				}
 			}
 
 			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
@@ -1733,115 +1881,108 @@ formateur_fichier(struct_processus *s_et
 			for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
 					.nombre_elements; i++)
 			{
-				if ((((*(*((struct_tableau *) (*s_format).objet))
-						.elements[i]).type == LST) &&
-						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
-						.type == LST)) ||
-						(((*(*((struct_tableau *) (*s_format).objet))
-						.elements[i]).type == TBL) &&
-						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
-						.type == TBL)))
+				if (format_sortie != 'N')
 				{
-					chaine_sauvegarde = chaine;
-
-					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*l_element_courant).donnee,
-							(*l_element_courant_format).donnee,
-							0, 0, ' ', 'F', longueur_effective, recursivite,
-							export_fichier)) == NULL)
-					{
-						return(NULL);
-					}
-
-					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
-							+ strlen(chaine_sauvegarde) + 2)
-							* sizeof(unsigned char));
-
-					if (chaine == NULL)
+					if ((((*(*((struct_tableau *) (*s_format).objet))
+							.elements[i]).type == LST) &&
+							((*(*((struct_tableau *) (*s_objet).objet))
+							.elements[i]).type == LST)) ||
+							(((*(*((struct_tableau *) (*s_format).objet))
+							.elements[i]).type == TBL) &&
+							((*(*((struct_tableau *) (*s_objet).objet))
+							.elements[i]).type == TBL)))
 					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						return(NULL);
-					}
-
-					strcpy(chaine, chaine_sauvegarde);
-					free(chaine_sauvegarde);
-					strcat(chaine, " ");
-					strcat(chaine, chaine_formatee);
-					free(chaine_formatee);
-				}
-				else if ((*(*((struct_tableau *) (*s_format).objet))
-						.elements[i]).type != CHN)
-				{
-					free(chaine);
+						chaine_sauvegarde = chaine;
 
-					(*s_etat_processus).erreur_execution =
-							d_ex_erreur_format_fichier;
-					return(NULL);
-				}
-				else
-				{
-					if ((format_chaine = conversion_majuscule((unsigned char *)
-							(*(*((struct_tableau *) (*s_format).objet))
-							.elements[i]).objet)) == NULL)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						return(NULL);
-					}
+						if ((chaine_formatee = formateur_fichier(
+								s_etat_processus,
+								(*(*((struct_tableau *) (*s_objet).objet))
+								.elements[i]).objet,
+								(*(*((struct_tableau *) (*s_format).objet))
+								.elements[i]).objet,
+								0, 0, ' ', 'F', longueur_effective, recursivite,
+								export_fichier)) == NULL)
+						{
+							return(NULL);
+						}
 
-					format_degenere = d_faux;
+						if ((chaine = (unsigned char *) malloc((strlen(
+								chaine_formatee) + strlen(chaine_sauvegarde)
+								+ 2) * sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
 
-					if (strncmp("STANDARD*", format_chaine, 9) == 0)
-					{
-						format_sortie = 'S';
-						position_1 = 9;
-						format_degenere = d_vrai;
-					}
-					else if (strncmp("BINARY*", format_chaine, 7) == 0)
-					{
-						format_sortie = 'B';
-						position_1 = 7;
-					}
-					else if (strncmp("FIXED*", format_chaine, 6) == 0)
-					{
-						format_sortie = 'F';
-						position_1 = 6;
-					}
-					else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
-					{
-						format_sortie = 'I';
-						position_1 = 11;
-					}
-					else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
-					{
-						format_sortie = 'E';
-						position_1 = 9;
-					}
-					else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
-					{
-						format_sortie = 'C';
-						position_1 = 10;
-						format_degenere = d_vrai;
+						strcpy(chaine, chaine_sauvegarde);
+						free(chaine_sauvegarde);
+						strcat(chaine, " ");
+						strcat(chaine, chaine_formatee);
+						free(chaine_formatee);
 					}
-					else
+					else if ((*(*((struct_tableau *) (*s_format).objet))
+							.elements[i]).type != CHN)
 					{
 						free(chaine);
-						free(format_chaine);
 
 						(*s_etat_processus).erreur_execution =
 								d_ex_erreur_format_fichier;
 						return(NULL);
 					}
+					else
+					{
+						if ((format_chaine = conversion_majuscule(
+								(unsigned char *) (*(*((struct_tableau *)
+								(*s_format).objet)).elements[i]).objet))
+								== NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
 
-					position_3 = strlen(format_chaine);
-					format_chaine[--position_3] = d_code_fin_chaine;
-
-					position_2 = position_1;
+						format_degenere = d_faux;
 
-					while(format_chaine[position_2] != '(')
-					{
-						if (format_chaine[position_2] == d_code_fin_chaine)
+						if (strncmp("STANDARD*", format_chaine, 9) == 0)
+						{
+							format_sortie = 'S';
+							position_1 = 9;
+							format_degenere = d_vrai;
+						}
+						else if (strncmp("BINARY*", format_chaine, 7) == 0)
+						{
+							format_sortie = 'B';
+							position_1 = 7;
+						}
+						else if (strncmp("FIXED*", format_chaine, 6) == 0)
+						{
+							format_sortie = 'F';
+							position_1 = 6;
+						}
+						else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
+						{
+							format_sortie = 'I';
+							position_1 = 11;
+						}
+						else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
+						{
+							format_sortie = 'E';
+							position_1 = 9;
+						}
+						else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
+						{
+							format_sortie = 'C';
+							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);
 							free(format_chaine);
@@ -1851,33 +1992,66 @@ formateur_fichier(struct_processus *s_et
 							return(NULL);
 						}
 
-						position_2++;
-					}
+						position_3 = (integer8) strlen(format_chaine);
+						format_chaine[--position_3] = d_code_fin_chaine;
 
-					format_chaine[position_2++] = d_code_fin_chaine;
+						position_2 = position_1;
 
-					if (format_degenere == d_faux)
-					{
-						if (sscanf(&(format_chaine[position_1]), "%ld",
-								&longueur) != 1)
+						while(format_chaine[position_2] != '(')
 						{
-							free(chaine);
-							free(format_chaine);
+							if (format_chaine[position_2] == d_code_fin_chaine)
+							{
+								free(chaine);
+								free(format_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);
+							}
+
+							position_2++;
 						}
-					}
-					else
-					{
-						longueur = -1;
-					}
 
-					if (strcmp(&(format_chaine[position_2]), "*") != 0)
-					{
-						if (sscanf(&(format_chaine[position_2]), "%ld",
-								&longueur_champ) != 1)
+						format_chaine[position_2++] = d_code_fin_chaine;
+
+						if (format_degenere == d_faux)
+						{
+							if (sscanf(&(format_chaine[position_1]), "%lld",
+									&longueur) != 1)
+							{
+								free(chaine);
+								free(format_chaine);
+
+								(*s_etat_processus).erreur_execution =
+										d_ex_erreur_format_fichier;
+								return(NULL);
+							}
+						}
+						else
+						{
+							longueur = -1;
+						}
+
+						if (strcmp(&(format_chaine[position_2]), "*") != 0)
+						{
+							if (sscanf(&(format_chaine[position_2]), "%lld",
+									&longueur_champ) != 1)
+							{
+								free(chaine);
+								free(format_chaine);
+
+								(*s_etat_processus).erreur_execution =
+										d_ex_erreur_format_fichier;
+								return(NULL);
+							}
+						}
+						else
+						{
+							longueur_champ = -1;
+						}
+
+						if ((longueur >= 0) && (longueur_champ >= 0) &&
+								(longueur > longueur_champ))
 						{
 							free(chaine);
 							free(format_chaine);
@@ -1886,98 +2060,97 @@ formateur_fichier(struct_processus *s_et
 									d_ex_erreur_format_fichier;
 							return(NULL);
 						}
-					}
-					else
-					{
-						longueur_champ = -1;
-					}
 
-					if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
-							longueur_champ))
-					{
-						free(chaine);
 						free(format_chaine);
+					
+						chaine_sauvegarde = chaine;
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_format_fichier;
-						return(NULL);
+						if ((chaine_formatee = formateur_fichier(
+								s_etat_processus, (*((struct_tableau *)
+								(*s_objet).objet)).elements[i], s_format,
+								longueur, longueur_champ, format_sortie, type,
+								longueur_effective, recursivite,
+								export_fichier)) == NULL)
+						{
+							return(NULL);
+						}
 					}
-
-					free(format_chaine);
-				
+				}
+				else // NATIVE*(*)
+				{
 					chaine_sauvegarde = chaine;
 
-					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*((struct_tableau *) (*s_objet).objet))
-							.elements[i], s_format,
+					if ((chaine_formatee = formateur_fichier(
+							s_etat_processus, (*((struct_tableau *)
+							(*s_objet).objet)).elements[i], s_format,
 							longueur, longueur_champ, format_sortie, type,
-							longueur_effective, recursivite, export_fichier))
-							== NULL)
+							longueur_effective, recursivite,
+							export_fichier)) == NULL)
 					{
 						return(NULL);
 					}
+				}
 
-					if ((*(*((struct_tableau *) (*s_objet).objet))
-							.elements[i]).type == CHN)
-					{
-						chaine = (unsigned char *)
-								malloc((strlen(chaine_formatee)
-								+ strlen(chaine_sauvegarde) + 4)
-								* sizeof(unsigned char));
-
-						if (chaine == NULL)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							return(NULL);
-						}
+				if ((*(*((struct_tableau *) (*s_objet).objet))
+						.elements[i]).type == CHN)
+				{
+					chaine = (unsigned char *)
+							malloc((strlen(chaine_formatee)
+							+ strlen(chaine_sauvegarde) + 4)
+							* sizeof(unsigned char));
 
-						strcpy(chaine, chaine_sauvegarde);
-						free(chaine_sauvegarde);
-						strcat(chaine, " \"");
-						strcat(chaine, chaine_formatee);
-						free(chaine_formatee);
-						strcat(chaine, "\"");
-					}
-					else if ((*(*((struct_tableau *) (*s_objet).objet))
-							.elements[i]).type == NOM)
+					if (chaine == NULL)
 					{
-						chaine = (unsigned char *)
-								malloc((strlen(chaine_formatee)
-								+ strlen(chaine_sauvegarde) + 2)
-								* sizeof(unsigned char));
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return(NULL);
+					}
 
-						if (chaine == NULL)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							return(NULL);
-						}
+					strcpy(chaine, chaine_sauvegarde);
+					free(chaine_sauvegarde);
+					strcat(chaine, " \"");
+					strcat(chaine, chaine_formatee);
+					free(chaine_formatee);
+					strcat(chaine, "\"");
+				}
+				else if ((*(*((struct_tableau *) (*s_objet).objet))
+						.elements[i]).type == NOM)
+				{
+					chaine = (unsigned char *)
+							malloc((strlen(chaine_formatee)
+							+ strlen(chaine_sauvegarde) + 2)
+							* sizeof(unsigned char));
 
-						sprintf(chaine, "%s %s", chaine_sauvegarde,
-								chaine_formatee);
-						free(chaine_formatee);
-					}
-					else
+					if (chaine == NULL)
 					{
-						chaine = (unsigned char *)
-								malloc((strlen(chaine_formatee)
-								+ strlen(chaine_sauvegarde) + 2)
-								* sizeof(unsigned char));
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return(NULL);
+					}
 
-						if (chaine == NULL)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							return(NULL);
-						}
+					sprintf(chaine, "%s %s", chaine_sauvegarde,
+							chaine_formatee);
+					free(chaine_formatee);
+				}
+				else
+				{
+					chaine = (unsigned char *)
+							malloc((strlen(chaine_formatee)
+							+ strlen(chaine_sauvegarde) + 2)
+							* sizeof(unsigned char));
 
-						strcpy(chaine, chaine_sauvegarde);
-						free(chaine_sauvegarde);
-						strcat(chaine, " ");
-						strcat(chaine, chaine_formatee);
-						free(chaine_formatee);
+					if (chaine == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return(NULL);
 					}
+
+					strcpy(chaine, chaine_sauvegarde);
+					free(chaine_sauvegarde);
+					strcat(chaine, " ");
+					strcat(chaine, chaine_formatee);
+					free(chaine_formatee);
 				}
 			}
 
@@ -2004,6 +2177,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2147,6 +2325,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2289,6 +2472,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2431,6 +2619,13 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
 			chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
 					(*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
 
@@ -2451,6 +2646,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2488,6 +2688,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2564,6 +2769,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2639,6 +2849,11 @@ formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'S';
+			}
+
 			if ((format_sortie != 'S') && (format_sortie != 'F') &&
 					(format_sortie != 'I') && (format_sortie != 'E'))
 			{
@@ -2715,7 +2930,7 @@ formateur_fichier(struct_processus *s_et
 			return(NULL);
 		}
 
-		(*longueur_effective) = strlen(chaine) + 1;
+		(*longueur_effective) = ((integer8) strlen(chaine)) + 1;
 	}
 	else
 	{
@@ -2873,6 +3088,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
@@ -2899,6 +3117,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 =
@@ -2919,16 +3143,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;
@@ -2945,6 +3169,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);
 
@@ -2971,15 +3208,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);
 			}
@@ -2988,7 +3225,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 =
@@ -2996,14 +3233,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 =
@@ -3011,15 +3250,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 =
@@ -3027,17 +3267,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 =
@@ -3045,7 +3286,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)
@@ -3054,12 +3295,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 =
@@ -3067,7 +3309,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)
@@ -3084,7 +3326,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;
 			}
 
@@ -3100,6 +3343,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 =
@@ -3124,6 +3373,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'))
 			{
@@ -3145,9 +3400,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))
@@ -3200,23 +3568,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;
@@ -3229,7 +3598,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 =
@@ -3246,7 +3616,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 =
@@ -3265,7 +3636,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 =
@@ -3288,7 +3660,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 =
@@ -3335,17 +3708,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 =
@@ -3354,7 +3743,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);
 				}
@@ -3403,6 +3792,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);
@@ -3425,7 +3820,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);
@@ -3445,19 +3840,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 =
@@ -3466,24 +3915,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);
 				}
 
+				if (format_sortie != 'N')
+				{
+					l_element_courant_format =
+							(*l_element_courant_format).suivant;
+				}
+
 				nombre_elements++;
 				l_element_courant = (*l_element_courant).suivant;
-				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;
@@ -3530,8 +3987,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)
 		{
@@ -3543,6 +4104,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 =
@@ -3605,9 +4172,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 =
@@ -3619,36 +4187,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 =
@@ -3659,9 +4252,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;
@@ -3697,7 +4287,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;
@@ -3837,12 +4427,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;
@@ -3855,8 +4446,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)
@@ -3882,7 +4471,7 @@ formateur_fichier_reel(struct_processus
 			exposant = 0;
 		}
 
-		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
 	}
 	else
 	{
@@ -3890,21 +4479,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)
@@ -3965,7 +4555,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)
@@ -3988,7 +4578,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));
@@ -4018,7 +4608,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;
@@ -4027,7 +4617,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;
@@ -4042,7 +4632,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] = '*';
 			}
@@ -4064,7 +4654,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;
 
@@ -4098,8 +4688,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;
 				}
 
@@ -4121,10 +4712,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;
 				}
 
@@ -4146,14 +4738,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;
 				}
 
@@ -4167,22 +4760,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;
 				}
 
@@ -4219,7 +4813,7 @@ formateur_fichier_binaire_nombre(struct_
 					}
 					else if (type_entree == 'I')
 					{
-						valeur = (*((integer8 *) valeur_numerique));
+						valeur = (real8) (*((integer8 *) valeur_numerique));
 					}
 					else
 					{
@@ -4256,11 +4850,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;
 				}
 
@@ -4281,7 +4875,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')
 					{
@@ -4295,15 +4889,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;
 				}
 
@@ -4327,8 +4921,8 @@ formateur_fichier_binaire_nombre(struct_
 					unsigned char		*partie_reelle;
 					unsigned char		*partie_imaginaire;
 
-					long				limag;
-					long				lreel;
+					integer8			limag;
+					integer8			lreel;
 
 					real8				zero;
 
@@ -4401,8 +4995,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);
@@ -4412,9 +5006,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);
@@ -4427,8 +5023,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')
@@ -4500,8 +5097,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);
@@ -4511,9 +5108,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);
@@ -4577,6 +5176,7 @@ lecture_fichier_non_formate(struct_proce
 	unsigned char				*buffer;
 	unsigned char				*flux;
 	unsigned char				*ptr;
+	unsigned char				type_objet;
 
 	size_t						deplacement;
 
@@ -4623,7 +5223,7 @@ lecture_fichier_non_formate(struct_proce
 		}
 	}
 
-	switch(octets[0] & 0xF0)
+	switch(type_objet = (octets[0] & 0xF0))
 	{
 		case 0x00:	// Binaire
 		{
@@ -4707,7 +5307,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;
@@ -4787,13 +5387,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;
@@ -4878,7 +5534,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;
@@ -4896,7 +5552,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;
@@ -4989,7 +5645,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)
@@ -5016,7 +5673,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)
@@ -5046,6 +5704,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
 			{
@@ -5230,9 +5890,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;
@@ -5481,7 +6158,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;
@@ -5489,7 +6167,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))
 					{
@@ -5542,6 +6220,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;
@@ -5572,7 +6779,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)