--- rpl/src/formateur_fichiers.c	2013/03/10 22:15:48	1.53
+++ rpl/src/formateur_fichiers.c	2013/03/11 11:07:24	1.54
@@ -100,6 +100,7 @@ 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;
@@ -2888,25 +2889,50 @@ 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 != 'L')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
 
-/*
---------------------------------------------------------------------------------
-  Entier binaire en base 2, 8, 10 ou 16
---------------------------------------------------------------------------------
-*/
+			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((*longueur_effective) * sizeof(unsigned char)))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
 
+			chaine[0] = longueur_champ;
+
+			for(i = 1; i <= (unsigned) (*longueur_effective); i++)
+			{
+				chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
+						(8 * (longueur_champ - i))) & 0xFF;
+			}
 		}
 		else if ((*s_objet).type == CHN)
 		{
@@ -3088,15 +3114,6 @@ formateur_fichier(struct_processus *s_et
 				return(NULL);
 			}
 		}
-		else if ((*s_objet).type == RPN)
-		{
-
-/*
---------------------------------------------------------------------------------
-  Définition
---------------------------------------------------------------------------------
-*/
-		}
 		else if ((*s_objet).type == INT)
 		{
 
@@ -3132,13 +3149,20 @@ formateur_fichier(struct_processus *s_et
 */
 
 		}
-		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 +3174,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 +3200,23 @@ formateur_fichier(struct_processus *s_et
 
 			if (longueur_liste < (1LL << 3))
 			{
-				chaine[0] = 0x40 | (longueur_liste & 0x7);
+				chaine[0] = type_binaire | (longueur_liste & 0x7);
 			}
 			else if (longueur_liste < (1LL << 8))
 			{
-				chaine[0] = 0x48;
+				chaine[0] = type_binaire | 0x08;
 			}
 			else if (longueur_liste < (1LL << 16))
 			{
-				chaine[0] = 0x49;
+				chaine[0] = type_binaire | 0x09;
 			}
 			else if (longueur_liste < (1LL << 32))
 			{
-				chaine[0] = 0x4A;
+				chaine[0] = type_binaire | 0x0A;
 			}
 			else
 			{
-				chaine[0] = 0x4B;
+				chaine[0] = type_binaire | 0x0B;
 			}
 
 			longueur_totale = 1;
@@ -4588,6 +4625,94 @@ lecture_fichier_non_formate(struct_proce
 
 	switch(octets[0] & 0xF0)
 	{
+		case 0x00:	// Binaire
+		{
+			switch(octets[0] & 0x0F)
+			{
+				case 0x01:	// logical*1
+				{
+					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))
+					{
+						(*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 * ((deplacement - 1) - i));
+			}
+
+			break;
+		}
+
 		case 0x10:	// Scalaire
 		{
 			switch(octets[0] & 0x0C)
@@ -4667,7 +4792,8 @@ lecture_fichier_non_formate(struct_proce
 					for(i = 0; i < (signed) deplacement; i++)
 					{
 						(*((integer8 *) (*s_objet).objet)) |=
-								octets[i] << (8 * ((deplacement - 1) - i));
+								((integer8) octets[i])
+								<< (8 * ((deplacement - 1) - i));
 					}
 
 					break;