--- rpl/src/formateur_fichiers.c	2013/03/10 17:01:05	1.52
+++ rpl/src/formateur_fichiers.c	2013/03/10 22:15:48	1.53
@@ -2744,7 +2744,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
@@ -3591,19 +3591,20 @@ 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] = (longueur_totale & 0xF0)
 								| 0x1 /* longueur supérieure à 7 bits */
 								| ((i + 1) << 1);
 
 						for(j = 0; j <= i; j++)
 						{
-							tampon[(i - j) + 1] = (longueur_totale >> (j + 1))
+							tampon[(i - j) + 1] =
+									(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] = ((longueur_totale & 0x0F) << 4)
 								| 0x1 /* longueur supérieure à 7 bits */
 								| ((i + 1) << 1);
 						break;
@@ -4525,6 +4526,8 @@ lecture_fichier_non_formate(struct_proce
 {
 	file						*fichier;
 
+	int							j;
+
 	integer8					i;
 	integer8					longueur;
 
@@ -4535,6 +4538,7 @@ lecture_fichier_non_formate(struct_proce
 
 	unsigned char				octets[8];
 	unsigned char				*buffer;
+	unsigned char				*flux;
 	unsigned char				*ptr;
 
 	size_t						deplacement;
@@ -4552,19 +4556,34 @@ lecture_fichier_non_formate(struct_proce
 		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)
@@ -4575,11 +4594,6 @@ lecture_fichier_non_formate(struct_proce
 			{
 				case 0x00:	// Entier
 				{
-					if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
-					{
-						return(NULL);
-					}
-
 					switch(octets[0] & 0x03)
 					{
 						case 0x00:	// integer*1
@@ -4612,19 +4626,42 @@ 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);
 						}
 					}
 
+					if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
+					{
+						return(NULL);
+					}
+
 					(*((integer8 *) (*s_objet).objet)) = 0;
 
 					for(i = 0; i < (signed) deplacement; i++)
@@ -4638,11 +4675,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 +4702,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
@@ -4725,11 +4781,131 @@ 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 * ((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 * ((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;
 				}
 
@@ -4760,14 +4936,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 +4975,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 +5015,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 +5057,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)
@@ -4933,7 +5170,249 @@ 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(longueur * sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				if (fread(flux, (size_t) sizeof(unsigned char),
+						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;
 		}
 
@@ -4953,7 +5432,15 @@ 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);
 		}
 
@@ -4966,7 +5453,15 @@ 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);
 			}
 		}