--- rpl/src/formateur_fichiers.c	2013/03/20 17:11:43	1.61
+++ rpl/src/formateur_fichiers.c	2015/03/26 11:10:46	1.84
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.21
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -19,7 +19,7 @@
 ================================================================================
 */
 
-#define DEBUG_ERREURS
+
 #include "rpl-conv.h"
 
 
@@ -85,6 +85,7 @@ formateur_fichier(struct_processus *s_et
 	struct_liste_chainee		*l_liste1;
 	struct_liste_chainee		*l_liste2;
 
+	struct_objet				*s_format_tmp;
 	struct_objet				*s_sous_objet;
 	struct_objet				*s_sous_objet_1;
 	struct_objet				*s_sous_objet_2;
@@ -94,6 +95,7 @@ formateur_fichier(struct_processus *s_et
 	unsigned char				*chaine;
 	unsigned char				*chaine_fonction;
 	unsigned char				*chaine_formatee;
+	unsigned char				*chaine_offset;
 	unsigned char				*chaine_tampon;
 	unsigned char				*chaine_sauvegarde;
 	unsigned char				*format_chaine;
@@ -111,8 +113,10 @@ formateur_fichier(struct_processus *s_et
 	integer8					nombre_lignes;
 
 	integer8					longueur_chaine_traitee;
+	integer8					longueur_element;
 	integer8					longueur_fonction;
 	integer8					longueur_liste;
+	integer8					longueur_objet;
 	integer8					longueur_reelle_chaine;
 	integer8					longueur_totale;
 	integer8					position_1;
@@ -233,6 +237,7 @@ formateur_fichier(struct_processus *s_et
 									.instruction_courante[1]
 									== '-')) ? d_vrai : d_faux;
 
+							(*s_etat_processus).type_en_cours = NON;
 							recherche_type(s_etat_processus);
 
 							if ((*s_etat_processus).erreur_execution != d_ex)
@@ -292,7 +297,8 @@ formateur_fichier(struct_processus *s_et
 									if ((strcmp(chaine_fonction, "AND") == 0) ||
 											(strcmp(chaine_fonction, "XOR") ==
 											0) || (strcmp(chaine_fonction, "OR")
-											== 0))
+											== 0) || (strcmp(chaine_fonction,
+											"EQV") == 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -319,7 +325,9 @@ formateur_fichier(struct_processus *s_et
 											|| (strcmp(chaine_fonction, "AND")
 											== 0) || (strcmp(chaine_fonction,
 											"XOR") == 0) || (strcmp(
-											chaine_fonction, "OR") == 0))
+											chaine_fonction, "OR") == 0) ||
+											(strcmp(chaine_fonction, "EQV")
+											== 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -400,6 +408,7 @@ formateur_fichier(struct_processus *s_et
 									"'%s'", (unsigned char *)
 									(*s_sous_objet_1).objet);
 
+							(*s_etat_processus).type_en_cours = NON;
 							recherche_type(s_etat_processus);
 
 							if ((*s_etat_processus).erreur_execution != d_ex)
@@ -457,7 +466,8 @@ formateur_fichier(struct_processus *s_et
 									if ((strcmp(chaine_fonction, "AND") == 0) ||
 											(strcmp(chaine_fonction, "XOR") ==
 											0) || (strcmp(chaine_fonction, "OR")
-											== 0))
+											== 0) || (strcmp(chaine_fonction,
+											"EQV") == 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -474,7 +484,9 @@ formateur_fichier(struct_processus *s_et
 											|| (strcmp(chaine_fonction, "AND")
 											== 0) || (strcmp(chaine_fonction,
 											"XOR") == 0) || (strcmp(
-											chaine_fonction, "OR") == 0))
+											chaine_fonction, "OR") == 0) ||
+											(strcmp(chaine_fonction, "EQV")
+											== 0))
 									{
 										autorisation_parenthese = d_vrai;
 									}
@@ -715,7 +727,9 @@ formateur_fichier(struct_processus *s_et
 								"XOR") == 0) || (strcmp((*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
 								.nom_fonction,
-								"AND") == 0))
+								"AND") == 0) || (strcmp((*((struct_fonction *)
+								(*(*l_element_courant).donnee).objet))
+								.nom_fonction, "EQV") == 0))
 						{
 							if (depilement(s_etat_processus,
 									&((*s_etat_processus)
@@ -1000,7 +1014,7 @@ formateur_fichier(struct_processus *s_et
 
 			if (format_sortie == 'N')
 			{
-				sprintf(tampon, "%llX", (*((logical8 *)
+				sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
 						((*s_objet).objet))));
 				strcpy(base, "h");
 			}
@@ -1010,8 +1024,8 @@ formateur_fichier(struct_processus *s_et
 				{
 					case 2:
 					{
-						sprintf(tampon, "%llX", (*((logical8 *)
-								((*s_objet).objet))));
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
 
 						chaine = (unsigned char *) malloc((strlen(tampon) + 1)
 								* sizeof(unsigned char));
@@ -1120,7 +1134,7 @@ formateur_fichier(struct_processus *s_et
 
 					case 8:
 					{
-						sprintf(tampon, "%llo", (*((logical8 *)
+						sprintf(tampon, "%llo", (*((unsigned long long *)
 								((*s_objet).objet))));
 						strcpy(base, "o");
 						break;
@@ -1128,7 +1142,7 @@ formateur_fichier(struct_processus *s_et
 
 					case 10:
 					{
-						sprintf(tampon, "%llu", (*((logical8 *)
+						sprintf(tampon, "%llu", (*((unsigned long long *)
 								((*s_objet).objet))));
 						strcpy(base, "d");
 						break;
@@ -1136,8 +1150,8 @@ formateur_fichier(struct_processus *s_et
 
 					case 16:
 					{
-						sprintf(tampon, "%llX", (*((logical8 *)
-								((*s_objet).objet))));
+						sprintf(tampon, "%llX", (unsigned long long)
+								(*((logical8 *) ((*s_objet).objet))));
 						strcpy(base, "h");
 						break;
 					}
@@ -1530,7 +1544,8 @@ formateur_fichier(struct_processus *s_et
 				}
 				else
 				{
-					if ((format_chaine = conversion_majuscule((unsigned char *)
+					if ((format_chaine = conversion_majuscule(
+							s_etat_processus, (unsigned char *)
 							(*(*l_element_courant_format).donnee).objet))
 							== NULL)
 					{
@@ -1673,16 +1688,70 @@ formateur_fichier(struct_processus *s_et
 				
 					chaine_sauvegarde = chaine;
 
+					// Si le format_sortie vaut 'N', on remplace le format par
+					// { "native*(*)" }. L'intérêt est de pouvoir traiter une
+					// liste par un format "native*(*)".
+
+					if ((format_sortie == 'N') && ((*(*l_element_courant)
+							.donnee).type == LST))
+					{
+						if ((s_format_tmp = allocation(s_etat_processus, LST))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*s_format_tmp).objet = allocation_maillon(
+								s_etat_processus)) == NULL)
+						{
+							return(NULL);
+						}
+
+						(*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.suivant = NULL;
+
+						if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.donnee = allocation(s_etat_processus, CHN))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*(*((struct_liste_chainee *) (*s_format_tmp)
+								.objet)).donnee).objet = malloc(11 *
+								sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
+
+						strcpy((unsigned char *) (*(*((struct_liste_chainee *)
+								(*s_format_tmp).objet)).donnee).objet,
+								"native*(*)");
+					}
+					else
+					{
+						if ((s_format_tmp = copie_objet(s_etat_processus,
+								s_format, 'P')) == NULL)
+						{
+							return(NULL);
+						}
+					}
+
 					if ((chaine_formatee = formateur_fichier(s_etat_processus,
 							(*l_element_courant).donnee, s_format,
 							longueur, longueur_champ, format_sortie, type,
 							longueur_effective, recursivite, export_fichier))
 							== NULL)
 					{
+						liberation(s_etat_processus, s_format_tmp);
 						free(chaine);
 						return(NULL);
 					}
 
+					liberation(s_etat_processus, s_format_tmp);
+
 					if ((*(*l_element_courant).donnee).type == CHN)
 					{
 						chaine = (unsigned char *)
@@ -1878,6 +1947,7 @@ formateur_fichier(struct_processus *s_et
 					else
 					{
 						if ((format_chaine = conversion_majuscule(
+								s_etat_processus,
 								(unsigned char *) (*(*((struct_tableau *)
 								(*s_format).objet)).elements[i]).objet))
 								== NULL)
@@ -3702,7 +3772,8 @@ formateur_fichier(struct_processus *s_et
 				}
 				else
 				{
-					if ((format_chaine = conversion_majuscule((unsigned char *)
+					if ((format_chaine = conversion_majuscule(
+							s_etat_processus, (unsigned char *)
 							(*(*l_element_courant_format).donnee).objet))
 							== NULL)
 					{
@@ -3785,17 +3856,71 @@ formateur_fichier(struct_processus *s_et
 					}
 
 					free(format_chaine);
-				
+
+					// Si le format_sortie vaut 'N', on remplace le format par
+					// { "native*(*)" }. L'intérêt est de pouvoir traiter une
+					// liste par un format "native*(*)".
+
+					if ((format_sortie == 'N') && ((*(*l_element_courant)
+							.donnee).type == LST))
+					{
+						if ((s_format_tmp = allocation(s_etat_processus, LST))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*s_format_tmp).objet = allocation_maillon(
+								s_etat_processus)) == NULL)
+						{
+							return(NULL);
+						}
+
+						(*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.suivant = NULL;
+
+						if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
+								.donnee = allocation(s_etat_processus, CHN))
+								== NULL)
+						{
+							return(NULL);
+						}
+
+						if (((*(*((struct_liste_chainee *) (*s_format_tmp)
+								.objet)).donnee).objet = malloc(11 *
+								sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return(NULL);
+						}
+
+						strcpy((unsigned char *) (*(*((struct_liste_chainee *)
+								(*s_format_tmp).objet)).donnee).objet,
+								"native*(*)");
+					}
+					else
+					{
+						if ((s_format_tmp = copie_objet(s_etat_processus,
+								s_format, 'P')) == NULL)
+						{
+							return(NULL);
+						}
+					}
+
 					if ((chaine_formatee = formateur_fichier(s_etat_processus,
-							(*l_element_courant).donnee, s_format,
+							(*l_element_courant).donnee, s_format_tmp,
 							longueur, longueur_champ, format_sortie, type,
 							longueur_effective, recursivite, export_fichier))
 							== NULL)
 					{
+						liberation(s_etat_processus, s_format_tmp);
 						free(chaine);
 						return(NULL);
 					}
 
+					liberation(s_etat_processus, s_format_tmp);
+
 					if ((chaine = realloc(chaine,
 							((size_t) (longueur_totale + (*longueur_effective)))
 							* sizeof(unsigned char))) == NULL)
@@ -3811,14 +3936,14 @@ formateur_fichier(struct_processus *s_et
 					free(chaine_formatee);
 				}
 
-				nombre_elements++;
-				l_element_courant = (*l_element_courant).suivant;
-
 				if (format_sortie != 'N')
 				{
 					l_element_courant_format =
 							(*l_element_courant_format).suivant;
 				}
+
+				nombre_elements++;
+				l_element_courant = (*l_element_courant).suivant;
 			}
 
 			if (format_sortie != 'N')
@@ -4023,6 +4148,127 @@ formateur_fichier(struct_processus *s_et
   Vecteur complexe
 --------------------------------------------------------------------------------
 */
+
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'C';
+				longueur = 16;
+			}
+
+			if (format_sortie != 'C')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
+
+			if (longueur_objet < (1LL << 8))
+			{
+				// Taille sur un octet
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(2 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xB2;
+				chaine[1] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 2;
+			}
+			else if (longueur_objet < (1LL << 16))
+			{
+				// Taille sur deux octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(3 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xB6;
+				chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 3;
+			}
+			else if (longueur_objet < (1LL << 32))
+			{
+				// Taille sur quatre octets
+				if ((chaine = malloc((size_t) (((*longueur_effective) =
+						5 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xBA;
+				chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[4] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 5;
+			}
+			else
+			{
+				// Taille sur huit octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(9 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xBE;
+				chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
+				chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 9;
+			}
+
+			switch(longueur)
+			{
+				case 8:
+				{
+					break;
+				}
+
+				default:
+				case 16:
+				{
+					chaine[0] |= 0x01;
+					break;
+				}
+			}
+
+			for(i = 0; i < longueur_objet; i++)
+			{
+				if ((chaine_tampon = formateur_fichier_binaire_nombre(
+						s_etat_processus, &(((complex16 *) (*((struct_vecteur *)
+						(*s_objet).objet)).tableau)[i]), 'C', format_sortie,
+						longueur, &longueur_element)) == NULL)
+				{
+					free(chaine);
+					return(NULL);
+				}
+
+				memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
+						(size_t) longueur);
+			}
 		}
 		else if ((*s_objet).type == VIN)
 		{
@@ -4032,6 +4278,161 @@ formateur_fichier(struct_processus *s_et
   Vecteur entier
 --------------------------------------------------------------------------------
 */
+
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'I';
+				longueur = 8;
+			}
+
+			if ((format_sortie != 'I') && (format_sortie != 'R')
+					&& (format_sortie != 'C'))
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
+
+			if (longueur_objet < (1LL << 8))
+			{
+				// Taille sur un octet
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(2 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0x20;
+				chaine[1] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 2;
+			}
+			else if (longueur_objet < (1LL << 16))
+			{
+				// Taille sur deux octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(3 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0x24;
+				chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 3;
+			}
+			else if (longueur_objet < (1LL << 32))
+			{
+				// Taille sur quatre octets
+				if ((chaine = malloc((size_t) (((*longueur_effective) =
+						5 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0x28;
+				chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[4] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 5;
+			}
+			else
+			{
+				// Taille sur huit octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(9 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0x2C;
+				chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
+				chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 9;
+			}
+
+			switch(format_sortie)
+			{
+				default:
+				case 'I':
+				{
+					break;
+				}
+
+				case 'R':
+				{
+					chaine[0] |= 0x80;
+					break;
+				}
+
+				case 'C':
+				{
+					chaine[0] |= 0x90;
+					break;
+				}
+			}
+
+			switch(longueur)
+			{
+				case 1:
+				{
+					break;
+				}
+
+				case 2:
+				{
+					chaine[0] |= 0x01;
+					break;
+				}
+
+				case 4:
+				{
+					chaine[0] |= 0x02;
+					break;
+				}
+
+				default:
+				case 8:
+				{
+					chaine[0] |= 0x03;
+					break;
+				}
+			}
+
+			for(i = 0; i < longueur_objet; i++)
+			{
+				if ((chaine_tampon = formateur_fichier_binaire_nombre(
+						s_etat_processus, &(((integer8 *) (*((struct_vecteur *)
+						(*s_objet).objet)).tableau)[i]), 'I', format_sortie,
+						longueur, &longueur_element)) == NULL)
+				{
+					free(chaine);
+					return(NULL);
+				}
+
+				memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
+						(size_t) longueur);
+			}
 		}
 		else if ((*s_objet).type == VRL)
 		{
@@ -4041,6 +4442,142 @@ formateur_fichier(struct_processus *s_et
   Vecteur réel
 --------------------------------------------------------------------------------
 */
+
+			if (format_sortie == 'N')
+			{
+				format_sortie = 'R';
+				longueur = 8;
+			}
+
+			if ((format_sortie != 'R') && (format_sortie != 'C'))
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
+
+			if (longueur_objet < (1LL << 8))
+			{
+				// Taille sur un octet
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(2 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xA2;
+				chaine[1] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 2;
+			}
+			else if (longueur_objet < (1LL << 16))
+			{
+				// Taille sur deux octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(3 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xA6;
+				chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 3;
+			}
+			else if (longueur_objet < (1LL << 32))
+			{
+				// Taille sur quatre octets
+				if ((chaine = malloc((size_t) (((*longueur_effective) =
+						5 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xAA;
+				chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[4] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 5;
+			}
+			else
+			{
+				// Taille sur huit octets
+				if ((chaine = malloc((size_t) ((*longueur_effective) =
+						(9 + (longueur_objet * longueur)))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xAE;
+				chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
+				chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_objet & 0xFF);
+				chaine_offset = chaine + 9;
+			}
+
+			switch(format_sortie)
+			{
+				default:
+				case 'R':
+				{
+					break;
+				}
+
+				case 'C':
+				{
+					chaine[0] |= 0x10;
+					break;
+				}
+			}
+
+			switch(longueur)
+			{
+				case 4:
+				{
+					break;
+				}
+
+				default:
+				case 8:
+				{
+					chaine[0] |= 0x01;
+					break;
+				}
+			}
+
+			for(i = 0; i < longueur_objet; i++)
+			{
+				if ((chaine_tampon = formateur_fichier_binaire_nombre(
+						s_etat_processus, &(((real8 *) (*((struct_vecteur *)
+						(*s_objet).objet)).tableau)[i]), 'R', format_sortie,
+						longueur, &longueur_element)) == NULL)
+				{
+					free(chaine);
+					return(NULL);
+				}
+
+				memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
+						(size_t) longueur);
+			}
 		}
 		else
 		{
@@ -4078,11 +4615,15 @@ formateur_fichier(struct_processus *s_et
 				memcpy(&(chaine[longueur_totale]), tampon, 1);
 				longueur_totale += 1;
 			}
-			else if (longueur_totale < (((integer8) 1) << 16))
+			else
 			{
 				longueur_totale++;
 
-				for(i = 0; i < 7; i++)
+				// i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
+
+				i = 0;
+
+				for(;;)
 				{
 					if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
 							|| (i == 6))
@@ -4106,9 +4647,29 @@ formateur_fichier(struct_processus *s_et
 								| ((i + 1) << 1));
 						break;
 					}
+
+					switch(i)
+					{
+						case 0 :
+						{
+							i = 2;
+							break;
+						}
+
+						case 2 :
+						{
+							i = 6;
+							break;
+						}
+					}
 				}
 
-				if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 3)
+				// i = 0 => +3 (16 bits)
+				// i = 2 => +5 (32 bits)
+				// i = 6 => +9 (64 bits)
+
+				if ((chaine = realloc(chaine, (((size_t) longueur_totale)
+						+ ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
 						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -4119,9 +4680,6 @@ formateur_fichier(struct_processus *s_et
 				memcpy(&(chaine[longueur_totale]), tampon, 3);
 				longueur_totale += 3;
 			}
-			else if (longueur_totale < (((integer8) 1) << 32))
-			{
-			}
 
 			__zone();
 			(*longueur_effective) = longueur_totale;
@@ -4303,6 +4861,7 @@ formateur_fichier_reel(struct_processus
 	real8					mantisse;
 	real8					tampon_reel;
 
+	integer8				i;
 	integer8				tampon_entier;
 
 	long					correction;
@@ -4315,8 +4874,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)
@@ -4365,7 +4922,7 @@ formateur_fichier_reel(struct_processus
 				pow(10, (double) exposant);
 	}
 
-	longueur_utile = longueur;
+	longueur_utile = (long) longueur;
 	longueur_utile_limite = 15;
 
 	if (longueur_utile > longueur_utile_limite)
@@ -4479,7 +5036,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;
@@ -4488,7 +5045,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;
@@ -4503,7 +5060,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] = '*';
 			}
@@ -4698,14 +5255,19 @@ formateur_fichier_binaire_nombre(struct_
 						vinf = nextafter(valeur, 0);
 						vsup = nextafter(valeur, valeur * 2);
 					}
-					else
+					else if (valeur < 0)
 					{
 						vinf = nextafter(valeur, valeur * 2);
 						vsup = nextafter(valeur, 0);
 					}
+					else
+					{
+						vinf = valeur;
+						vsup = valeur;
+					}
 
-					if (!((vinf <= ((real4) valeur)) &&
-							(((real4) valeur) <= vsup)))
+					if (!((((real4) vinf) <= ((real4) valeur)) &&
+							(((real4) valeur) <= ((real4) vsup))))
 					{
 						(*s_etat_processus).erreur_execution =
 								d_ex_representation;
@@ -5258,13 +5820,69 @@ lecture_fichier_non_formate(struct_proce
 						return(NULL);
 					}
 
-					(*((integer8 *) (*s_objet).objet)) = 0;
+					// Récupération des données avec extension de signe.
 
-					for(i = 0; i < (signed) deplacement; i++)
 					{
-						(*((integer8 *) (*s_objet).objet)) |=
-								((integer8) octets[i])
-								<< (8 * ((((signed) 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;