--- rpl/src/formateur_fichiers.c	2013/03/10 17:01:05	1.52
+++ rpl/src/formateur_fichiers.c	2013/03/23 18:00:09	1.66
@@ -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,15 +72,13 @@ 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;
@@ -100,19 +100,21 @@ formateur_fichier(struct_processus *s_et
 	unsigned char				*ptre;
 	unsigned char				*ptrl;
 	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;
@@ -131,8 +133,6 @@ formateur_fichier(struct_processus *s_et
 
 		strcpy(base, " ");
 
-		masque_binaire = 0;
-
 		if ((*s_objet).type == ALG)
 		{
 
@@ -142,6 +142,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)
@@ -921,8 +928,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;
 
@@ -984,157 +991,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", (*((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", (*((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", (*((logical8 *)
+								((*s_objet).objet))));
+						strcpy(base, "o");
+						break;
 					}
 
-					strcpy(chaine, tampon);
-					tampon[0] = 0;
+					case 10:
+					{
+						sprintf(tampon, "%llu", (*((logical8 *)
+								((*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", (*((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;
 				}
 			}
 
@@ -1161,7 +1192,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;
@@ -1171,6 +1202,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))
 			{
@@ -1193,7 +1229,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 =
@@ -1202,7 +1238,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;
 			}
 		}
@@ -1215,6 +1251,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'))
 			{
@@ -1252,6 +1293,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;
 
@@ -1334,6 +1382,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'))
 			{
@@ -1371,6 +1424,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));
@@ -1418,13 +1478,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)
@@ -1497,6 +1573,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);
@@ -1507,7 +1589,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] != ')')
 					{
@@ -1542,7 +1624,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);
@@ -1560,7 +1642,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);
@@ -1577,7 +1659,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);
@@ -1664,17 +1746,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;
@@ -1700,23 +1794,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));
@@ -1732,115 +1826,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)
+					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)))
 					{
-						return(NULL);
-					}
-
-					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
-							+ strlen(chaine_sauvegarde) + 2)
-							* sizeof(unsigned char));
-
-					if (chaine == NULL)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						return(NULL);
-					}
-
-					strcpy(chaine, chaine_sauvegarde);
-					free(chaine_sauvegarde);
-					strcat(chaine, " ");
-					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);
@@ -1850,33 +1937,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);
@@ -1885,98 +2005,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);
 				}
 			}
 
@@ -2003,6 +2122,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'))
 			{
@@ -2146,6 +2270,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'))
 			{
@@ -2288,6 +2417,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'))
 			{
@@ -2430,6 +2564,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));
 
@@ -2450,6 +2591,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'))
 			{
@@ -2487,6 +2633,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'))
 			{
@@ -2563,6 +2714,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'))
 			{
@@ -2638,6 +2794,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'))
 			{
@@ -2714,7 +2875,7 @@ formateur_fichier(struct_processus *s_et
 			return(NULL);
 		}
 
-		(*longueur_effective) = strlen(chaine) + 1;
+		(*longueur_effective) = ((integer8) strlen(chaine)) + 1;
 	}
 	else
 	{
@@ -2744,7 +2905,7 @@ formateur_fichier(struct_processus *s_et
 		 *
 		 * XXXXXXX0								longueur sur 7 bits
 		 * XXXX0011 XXXXXXXX XXXX0011			longueur sur 16 bits
-		 * MSB(1/2) LSB      MSB(2/2)
+		 * LSB(1/2) MSB      LSB(2/2)
 		 * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101	longueur sur 24 bits
 		 * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX
 		 *          XXXX0111					longueur sur 32 bits
@@ -2872,6 +3033,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
@@ -2888,25 +3052,56 @@ formateur_fichier(struct_processus *s_et
 		chaine_formatee = NULL;
 		chaine_sauvegarde = NULL;
 
-		if ((*s_objet).type == ALG)
+		if ((*s_objet).type == BIN)
 		{
 
 /*
 --------------------------------------------------------------------------------
-  Expression algébrique
+  Entier binaire en base 2, 8, 10 ou 16
+  Poids fort 0000
 --------------------------------------------------------------------------------
 */
 
-		}
-		else if ((*s_objet).type == BIN)
-		{
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'L';
+				longueur_champ = 8;
+			}
 
-/*
---------------------------------------------------------------------------------
-  Entier binaire en base 2, 8, 10 ou 16
---------------------------------------------------------------------------------
-*/
+			if (format_sortie != 'L')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			if (longueur_champ < 8)
+			{
+				if ((*((logical8 *) (*s_objet).objet)) >=
+						((logical8) 1 << (8 * longueur_champ)))
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_representation;
+					return(NULL);
+				}
+			}
+
+			(*longueur_effective) = longueur_champ + 1;
+
+			if ((chaine = malloc(((size_t) (*longueur_effective))
+				 	* sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
 
+			chaine[0] = (unsigned char) longueur_champ;
+
+			for(i = 1; i <= (*longueur_effective); i++)
+			{
+				chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
+						(8 * (longueur_champ - i))) & 0xFF;
+			}
 		}
 		else if ((*s_objet).type == CHN)
 		{
@@ -2919,6 +3114,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);
 
@@ -2945,15 +3153,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);
 			}
@@ -2962,7 +3170,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 =
@@ -2970,14 +3178,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 =
@@ -2985,15 +3195,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 =
@@ -3001,17 +3212,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 =
@@ -3019,7 +3231,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)
@@ -3028,12 +3240,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 =
@@ -3041,7 +3254,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)
@@ -3058,7 +3271,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;
 			}
 
@@ -3074,6 +3288,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 =
@@ -3088,15 +3308,6 @@ formateur_fichier(struct_processus *s_et
 				return(NULL);
 			}
 		}
-		else if ((*s_objet).type == RPN)
-		{
-
-/*
---------------------------------------------------------------------------------
-  Définition
---------------------------------------------------------------------------------
-*/
-		}
 		else if ((*s_objet).type == INT)
 		{
 
@@ -3107,6 +3318,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'))
 			{
@@ -3128,17 +3345,137 @@ 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)
+		else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
+				|| ((*s_objet).type == RPN))
 		{
 
 /*
 --------------------------------------------------------------------------------
   Liste
   Poids fort 0100
+
+  Expression algébrique
+  Poids fort 0111
+
+  Définition
+  Poids fort 0110
 --------------------------------------------------------------------------------
 */
 
@@ -3150,6 +3487,19 @@ formateur_fichier(struct_processus *s_et
 				return(NULL);
 			}
 
+			if ((*s_objet).type == LST)
+			{
+				type_binaire = 0x40;
+			}
+			else if ((*s_objet).type == RPN)
+			{
+				type_binaire = 0x60;
+			}
+			else // ALG
+			{
+				type_binaire = 0x70;
+			}
+
 			// Calcul de la longueur de la liste.
 
 			longueur_liste = 0;
@@ -3163,23 +3513,24 @@ formateur_fichier(struct_processus *s_et
 
 			if (longueur_liste < (1LL << 3))
 			{
-				chaine[0] = 0x40 | (longueur_liste & 0x7);
+				chaine[0] = (unsigned char) (type_binaire |
+						(longueur_liste & 0x7));
 			}
 			else if (longueur_liste < (1LL << 8))
 			{
-				chaine[0] = 0x48;
+				chaine[0] = (unsigned char) (type_binaire | 0x08);
 			}
 			else if (longueur_liste < (1LL << 16))
 			{
-				chaine[0] = 0x49;
+				chaine[0] = (unsigned char ) (type_binaire | 0x09);
 			}
 			else if (longueur_liste < (1LL << 32))
 			{
-				chaine[0] = 0x4A;
+				chaine[0] = (unsigned char) (type_binaire | 0x0A);
 			}
 			else
 			{
-				chaine[0] = 0x4B;
+				chaine[0] = (unsigned char) (type_binaire | 0x0B);
 			}
 
 			longueur_totale = 1;
@@ -3192,7 +3543,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 =
@@ -3209,7 +3561,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 =
@@ -3228,7 +3581,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 =
@@ -3251,7 +3605,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 =
@@ -3298,17 +3653,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 =
@@ -3317,7 +3688,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);
 				}
@@ -3366,6 +3737,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);
@@ -3388,7 +3765,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);
@@ -3420,7 +3797,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 =
@@ -3429,24 +3806,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;
@@ -3493,8 +3878,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)
 		{
@@ -3506,6 +3995,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 =
@@ -3568,9 +4063,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 =
@@ -3591,26 +4087,28 @@ formateur_fichier(struct_processus *s_et
 					if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
 							|| (i == 6))
 					{
-						// MSB (4 bits de poids fort)
-						tampon[0] = ((longueur_totale >> 8) & 0xF0)
+						// LSB (4 bits de poids fort)
+						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 >> (j + 1))
-									& 0xFF;
+							tampon[(i - j) + 1] = (unsigned char)
+									((longueur_totale >> (8 * (j + 1)))
+									& 0xFF);
 						}
 
-						// MSB (4 bits de poids faible)
-						tampon[i + 2] = (((longueur_totale >> 8) & 0x0F) << 4)
+						// LSB (4 bits de poids faible)
+						tampon[i + 2] = (unsigned char)
+								(((longueur_totale & 0x0F) << 4)
 								| 0x1 /* longueur supérieure à 7 bits */
-								| ((i + 1) << 1);
+								| ((i + 1) << 1));
 						break;
 					}
 				}
 
-				if ((chaine = realloc(chaine, (longueur_totale + 3)
+				if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 3)
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3659,7 +4157,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;
@@ -3799,12 +4297,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;
@@ -3817,8 +4316,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)
@@ -3844,7 +4341,7 @@ formateur_fichier_reel(struct_processus
 			exposant = 0;
 		}
 
-		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+		mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
 	}
 	else
 	{
@@ -3852,21 +4349,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)
@@ -3927,7 +4425,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)
@@ -3950,7 +4448,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));
@@ -3980,7 +4478,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;
@@ -3989,7 +4487,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;
@@ -4004,7 +4502,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] = '*';
 			}
@@ -4026,7 +4524,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;
 
@@ -4060,8 +4558,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;
 				}
 
@@ -4083,17 +4582,18 @@ 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;
 				}
 
 				case 4:
 				{
 					if ((*((integer8 *) valeur_numerique)) !=
-							((integer2) (*((integer8 *) valeur_numerique))))
+							((integer4) (*((integer8 *) valeur_numerique))))
 					{
 						(*s_etat_processus).erreur_execution =
 								d_ex_representation;
@@ -4108,14 +4608,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;
 				}
 
@@ -4129,22 +4630,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;
 				}
 
@@ -4181,7 +4683,7 @@ formateur_fichier_binaire_nombre(struct_
 					}
 					else if (type_entree == 'I')
 					{
-						valeur = (*((integer8 *) valeur_numerique));
+						valeur = (real8) (*((integer8 *) valeur_numerique));
 					}
 					else
 					{
@@ -4218,11 +4720,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;
 				}
 
@@ -4243,7 +4745,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')
 					{
@@ -4257,15 +4759,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;
 				}
 
@@ -4289,8 +4791,8 @@ formateur_fichier_binaire_nombre(struct_
 					unsigned char		*partie_reelle;
 					unsigned char		*partie_imaginaire;
 
-					long				limag;
-					long				lreel;
+					integer8			limag;
+					integer8			lreel;
 
 					real8				zero;
 
@@ -4363,8 +4865,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);
@@ -4374,9 +4876,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);
@@ -4389,8 +4893,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')
@@ -4462,8 +4967,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);
@@ -4473,9 +4978,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);
@@ -4525,6 +5032,8 @@ lecture_fichier_non_formate(struct_proce
 {
 	file						*fichier;
 
+	int							j;
+
 	integer8					i;
 	integer8					longueur;
 
@@ -4535,7 +5044,9 @@ lecture_fichier_non_formate(struct_proce
 
 	unsigned char				octets[8];
 	unsigned char				*buffer;
+	unsigned char				*flux;
 	unsigned char				*ptr;
+	unsigned char				type_objet;
 
 	size_t						deplacement;
 
@@ -4547,39 +5058,137 @@ lecture_fichier_non_formate(struct_proce
 	}
 	else
 	{
-		buffer = argument;
+		buffer = (*((unsigned char **) argument));
 		ptr = buffer;
 		fichier = NULL;
 	}
 
-
 	if (longueur_buffer < 0)
 	{
 		if (fread(octets, (size_t) sizeof(unsigned char),
 				1, fichier) != 1)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+			if (feof(fichier))
+			{
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+			}
+			else
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+			}
+
 			return(NULL);
 		}
 	}
 	else
 	{
-		octets[0] = *ptr++;
+		if ((longueur_buffer - (ptr - buffer)) >= 1)
+		{
+			octets[0] = *ptr++;
+		}
+		else
+		{
+			(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+			return(NULL);
+		}
 	}
 
-	switch(octets[0] & 0xF0)
+	switch(type_objet = (octets[0] & 0xF0))
 	{
-		case 0x10:	// Scalaire
+		case 0x00:	// Binaire
 		{
-			switch(octets[0] & 0x0C)
+			switch(octets[0] & 0x0F)
 			{
-				case 0x00:	// Entier
+				case 0x01:	// logical*1
 				{
-					if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
+					deplacement = 1;
+					break;
+				}
+
+				case 0x02:	// logical*2
+				{
+					deplacement = 2;
+					break;
+				}
+
+				case 0x04:	// logical*4
+				{
+					deplacement = 4;
+					break;
+				}
+
+				case 0x08:	// logical*8
+				{
+					deplacement = 8;
+					break;
+				}
+
+				default:
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_syntaxe;
+					return(NULL);
+				}
+			}
+
+			if (longueur_buffer < 0)
+			{
+				if (fread(octets, (size_t) sizeof(unsigned char),
+						deplacement, fichier) != deplacement)
+				{
+					if (feof(fichier))
 					{
-						return(NULL);
+						(*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)) >=
+						(ssize_t) deplacement)
+				{
+					for(i = 0; i < (signed) deplacement; i++)
+					{
+						octets[i] = *ptr++;
+					}
+				}
+				else
+				{
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					return(NULL);
+				}
+			}
 
+			if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
+			{
+				return(NULL);
+			}
+
+			(*((logical8 *) (*s_objet).objet)) = 0;
+
+			for(i = 0; i < (signed) deplacement; i++)
+			{
+				(*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
+						<< (8 * ((((signed) deplacement) - 1) - i));
+			}
+
+			break;
+		}
+
+		case 0x10:	// Scalaire
+		{
+			switch(octets[0] & 0x0C)
+			{
+				case 0x00:	// Entier
+				{
 					switch(octets[0] & 0x03)
 					{
 						case 0x00:	// integer*1
@@ -4612,25 +5221,105 @@ lecture_fichier_non_formate(struct_proce
 						if (fread(octets, (size_t) sizeof(unsigned char),
 								deplacement, fichier) != deplacement)
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
+							if (feof(fichier))
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+							}
+
 							return(NULL);
 						}
 					}
 					else
 					{
-						for(i = 0; i < (signed) deplacement; i++)
+						if ((longueur_buffer - (ptr - buffer)) >=
+								(ssize_t) deplacement)
+						{
+							for(i = 0; i < (signed) deplacement; i++)
+							{
+								octets[i] = *ptr++;
+							}
+						}
+						else
 						{
-							octets[i] = *ptr++;
+							(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+							return(NULL);
 						}
 					}
 
-					(*((integer8 *) (*s_objet).objet)) = 0;
+					if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
+					{
+						return(NULL);
+					}
+
+					// Récupération des données avec extension de signe.
 
-					for(i = 0; i < (signed) deplacement; i++)
 					{
-						(*((integer8 *) (*s_objet).objet)) |=
-								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;
@@ -4638,11 +5327,6 @@ lecture_fichier_non_formate(struct_proce
 
 				case 0x04:	// Réel
 				{
-					if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
-					{
-						return(NULL);
-					}
-
 					switch(octets[0] & 0x03)
 					{
 						case 0x00:	// real*4
@@ -4670,19 +5354,43 @@ lecture_fichier_non_formate(struct_proce
 						if (fread(octets, (size_t) sizeof(unsigned char),
 								deplacement, fichier) != deplacement)
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
+							if (feof(fichier))
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+							}
+
 							return(NULL);
 						}
 					}
 					else
 					{
-						for(i = 0; i < (signed) deplacement; i++)
+						if ((longueur_buffer - (ptr - buffer)) >=
+								(ssize_t) deplacement)
 						{
-							octets[i] = *ptr++;
+							for(i = 0; i < (signed) deplacement; i++)
+							{
+								octets[i] = *ptr++;
+							}
+						}
+						else
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_syntaxe;
+							return(NULL);
 						}
 					}
 
+					if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
+					{
+						return(NULL);
+					}
+
 					if (deplacement == 4)
 					{
 						union
@@ -4696,7 +5404,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;
@@ -4714,7 +5422,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;
@@ -4725,11 +5433,133 @@ lecture_fichier_non_formate(struct_proce
 
 				case 0x08:	// Complexe
 				{
+					switch(octets[0] & 0x03)
+					{
+						case 0x00:	// complex*8
+						{
+							deplacement = 4;
+							break;
+						}
+
+						case 0x01:	// complex*16
+						{
+							deplacement = 8;
+							break;
+						}
+
+						default:
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_syntaxe;
+							return(NULL);
+						}
+					}
+
 					if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
 					{
 						return(NULL);
 					}
 
+					for(j = 0; j < 2; j++)
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									deplacement, fichier) != deplacement)
+							{
+								liberation(s_etat_processus, s_objet);
+
+								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)) >=
+									(ssize_t) deplacement)
+							{
+								for(i = 0; i < (signed) deplacement; i++)
+								{
+									octets[i] = *ptr++;
+								}
+							}
+							else
+							{
+								liberation(s_etat_processus, s_objet);
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						if (deplacement == 4)
+						{
+							union
+							{
+								real4		r4;
+								integer4	i4;
+							} eq4;
+
+							eq4.i4 = 0;
+
+							for(i = 0; i < (signed) deplacement; i++)
+							{
+								eq4.i4 |= ((integer4) octets[i]) <<
+										(8 * ((((signed) deplacement) - 1)
+										- i));
+							}
+
+							if (j == 0)
+							{
+								(*((complex16 *) (*s_objet).objet))
+										.partie_reelle = (real8) eq4.r4;
+							}
+							else
+							{
+								(*((complex16 *) (*s_objet).objet))
+										.partie_imaginaire = (real8) eq4.r4;
+							}
+						}
+						else
+						{
+							union
+							{
+								real8		r8;
+								integer8	i8;
+							} eq8;
+
+							eq8.i8 = 0;
+
+							for(i = 0; i < (signed) deplacement; i++)
+							{
+								eq8.i8 |= ((integer8) octets[i]) <<
+										(8 * ((((signed) deplacement) - 1)
+										- i));
+							}
+
+							if (j == 0)
+							{
+								(*((complex16 *) (*s_objet).objet))
+										.partie_reelle = (real8) eq8.r8;
+							}
+							else
+							{
+								(*((complex16 *) (*s_objet).objet))
+										.partie_imaginaire = (real8) eq8.r8;
+							}
+						}
+					}
+
 					break;
 				}
 
@@ -4744,6 +5574,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
 			{
@@ -4760,14 +5592,32 @@ lecture_fichier_non_formate(struct_proce
 							if (fread(octets, (size_t) sizeof(unsigned char),
 									1, fichier) != 1)
 							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_erreur_fichier;
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
 								return(NULL);
 							}
 						}
 						else
 						{
-							octets[0] = *ptr++;
+							if ((longueur_buffer - (ptr - buffer)) >= 1)
+							{
+								octets[0] = *ptr++;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
 						}
 
 						longueur = octets[0];
@@ -4781,15 +5631,32 @@ lecture_fichier_non_formate(struct_proce
 							if (fread(octets, (size_t) sizeof(unsigned char),
 									2, fichier) != 2)
 							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_erreur_fichier;
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
 								return(NULL);
 							}
 						}
 						else
 						{
-							octets[0] = *ptr++;
-							octets[1] = *ptr++;
+							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)
@@ -4804,17 +5671,32 @@ lecture_fichier_non_formate(struct_proce
 							if (fread(octets, (size_t) sizeof(unsigned char),
 									4, fichier) != 4)
 							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_erreur_fichier;
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
 								return(NULL);
 							}
 						}
 						else
 						{
-							octets[0] = *ptr++;
-							octets[1] = *ptr++;
-							octets[2] = *ptr++;
-							octets[3] = *ptr++;
+							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)
@@ -4831,21 +5713,32 @@ lecture_fichier_non_formate(struct_proce
 							if (fread(octets, (size_t) sizeof(unsigned char),
 									8, fichier) != 8)
 							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_erreur_fichier;
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
 								return(NULL);
 							}
 						}
 						else
 						{
-							octets[0] = *ptr++;
-							octets[1] = *ptr++;
-							octets[2] = *ptr++;
-							octets[3] = *ptr++;
-							octets[4] = *ptr++;
-							octets[5] = *ptr++;
-							octets[6] = *ptr++;
-							octets[7] = *ptr++;
+							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)
@@ -4867,9 +5760,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;
@@ -4933,7 +5843,779 @@ lecture_fichier_non_formate(struct_proce
 
 		case 0x80:	// Chaîne de caractères
 		{
-			s_objet = NULL;
+			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 (longueur_buffer < 0)
+			{
+				if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				if (fread(flux, (size_t) sizeof(unsigned char),
+						(size_t) longueur, fichier) != (size_t) longueur)
+				{
+					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)) < longueur)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_syntaxe;
+					return(NULL);
+				}
+
+				flux = ptr;
+				ptr += longueur;
+			}
+
+			if ((s_objet = allocation(s_etat_processus, CHN)) == NULL)
+			{
+				if (longueur_buffer < 0)
+				{
+					free(flux);
+				}
+
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (((*s_objet).objet = analyse_flux(s_etat_processus, flux,
+					longueur)) == NULL)
+			{
+				return(NULL);
+			}
+
+			if (longueur_buffer < 0)
+			{
+				free(flux);
+			}
+
+			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;
 		}
 
@@ -4953,25 +6635,46 @@ lecture_fichier_non_formate(struct_proce
 		{
 			liberation(s_etat_processus, s_objet);
 
-			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+			if (feof(fichier))
+			{
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+			}
+			else
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+			}
+
 			return(NULL);
 		}
 
 		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)
 			{
 				liberation(s_etat_processus, s_objet);
 
-				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				if (feof(fichier))
+				{
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+				}
+				else
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				}
+
 				return(NULL);
 			}
 		}
 	}
 
+	if (longueur_buffer >= 0)
+	{
+		(*((unsigned char **) argument)) = ptr;
+	}
+
 	return(s_objet);
 }