--- rpl/src/instructions_r4.c	2010/03/08 16:44:10	1.8
+++ rpl/src/instructions_r4.c	2019/01/01 09:03:09	1.109
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.12
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.30
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -96,8 +96,8 @@ instruction_r_vers_b(struct_processus *s
 		}
 		else
 		{
-			(*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
-					(*s_objet_argument).objet));
+			(*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
+					(*((integer8 *) (*s_objet_argument).objet));
 		}
 	}
 	else
@@ -848,23 +848,32 @@ instruction_read(struct_processus *s_eta
 {
 	const char						*queue;
 
+	int								c;
 	int								ios;
+	int								timeout;
 
 	integer8						element;
+	integer8						i;
 	integer8						id;
+	integer8						index;
+	integer8						longueur;
 	integer8						position_clef;
 
+	integer8						longueur_effective;
+	integer8						longueur_enregistrement;
+	integer8						longueur_questure;
+	integer8						niveau;
+	integer8						pointeur;
+	integer8						position_finale;
+	integer8						position_initiale;
+
+	logical1						device;
+	logical1						format_degenere;
+	logical1						format_oriente_ligne;
 	logical1						indicateur_48;
 	logical1						presence_chaine;
 	logical1						presence_indicateur;
-
-	long							longueur_effective;
-	long							longueur_enregistrement;
-	long							longueur_questure;
-	long							niveau;
-	long							pointeur;
-	long							position_finale;
-	long							position_initiale;
+	logical1						trame_complete;
 
 	socklen_t						longueur_adresse;
 
@@ -872,15 +881,22 @@ instruction_read(struct_processus *s_eta
 
 	struct flock					lock;
 
+	struct pollfd					fds[1];
+
 	struct sockaddr_un				adresse_unix;
 	struct sockaddr_in				adresse_ipv4;
+#	ifdef IPV6
 	struct sockaddr_in6				adresse_ipv6;
+#	endif
+
+	struct termios					tc;
 
 	struct timespec					attente;
 
 	struct_descripteur_fichier		*descripteur;
 
 	struct_liste_chainee			*l_element_courant;
+	struct_liste_chainee			*l_element_courant_format;
 	struct_liste_chainee			*l_element_inclus;
 
 	struct_objet					*s_objet_adresse;
@@ -892,16 +908,46 @@ instruction_read(struct_processus *s_eta
 	unsigned char					caractere;
 	unsigned char					*clef_utf8;
 	unsigned char					*commande;
+	unsigned char					*format_chaine;
+	unsigned char					*ptr;
 	unsigned char					*tampon_lecture;
 	unsigned char					*tampon;
 	unsigned char					*tampon2;
+	unsigned char					*tampon3;
 
-	unsigned long					i;
+	int								vitesses[] =
+						{
+							50, 75, 110, 134, 150, 200, 300, 600,
+							1200, 1800, 2400, 4800, 9600, 19200, 38400,
+#ifdef B57600
+							57600,
+#endif
+#ifdef B115200
+							115200,
+#endif
+#ifdef B230400
+							230400,
+#endif
+							0
+						};
 
-	(*s_etat_processus).erreur_execution = d_ex;
+	tcflag_t						vitesses_constantes[] =
+						{
+							B50, B75, B110, B134, B150, B200, B300, B600,
+							B1200, B1800, B2400, B4800, B9600, B19200, B38400,
+#ifdef B57600
+							B57600,
+#endif
+#ifdef B115200
+							B115200,
+#endif
+#ifdef B230400
+							B230400,
+#endif
+							0
+						};
 
-	attente.tv_sec = 0;
-	attente.tv_nsec = GRANULARITE_us * 1000;
+	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
 	{
@@ -1044,9 +1090,9 @@ instruction_read(struct_processus *s_eta
 				 * Fichiers séquentiels
 				 */
 
-				longueur_questure = 256;
+				longueur_questure = 4096;
 
-				if ((tampon_lecture = malloc(longueur_questure *
+				if ((tampon_lecture = malloc(((size_t) longueur_questure) *
 						sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1065,8 +1111,8 @@ instruction_read(struct_processus *s_eta
 
 				do
 				{
-					longueur_effective = fread(tampon_lecture,
-							(size_t) sizeof(unsigned char), longueur_questure,
+					longueur_effective = (integer8) fread(tampon_lecture,
+							sizeof(unsigned char), (size_t) longueur_questure,
 							(*descripteur).descripteur_c);
 
 					pointeur = 0;
@@ -1104,7 +1150,7 @@ instruction_read(struct_processus *s_eta
 				presence_chaine = d_faux;
 				niveau = 1;
 
-				if (fseek((*descripteur).descripteur_c, position_finale,
+				if (fseek((*descripteur).descripteur_c, (long) position_finale,
 						SEEK_SET) != 0)
 				{
 					liberation(s_etat_processus, s_objet_argument_1);
@@ -1116,8 +1162,8 @@ instruction_read(struct_processus *s_eta
 
 				do
 				{
-					longueur_effective = fread(tampon_lecture,
-							(size_t) sizeof(unsigned char), longueur_questure,
+					longueur_effective = (integer8) fread(tampon_lecture,
+							sizeof(unsigned char), (size_t) longueur_questure,
 							(*descripteur).descripteur_c);
 
 					pointeur = 0;
@@ -1185,7 +1231,8 @@ instruction_read(struct_processus *s_eta
 				free(tampon_lecture);
 				longueur_enregistrement = position_finale - position_initiale;
 
-				if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
+				if ((tampon_lecture = malloc(((size_t)
+						(longueur_enregistrement + 1)) *
 						sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1193,8 +1240,8 @@ instruction_read(struct_processus *s_eta
 					return;
 				}
 
-				if (fseek((*descripteur).descripteur_c, position_initiale,
-						SEEK_SET) != 0)
+				if (fseek((*descripteur).descripteur_c,
+						(long) position_initiale, SEEK_SET) != 0)
 				{
 					liberation(s_etat_processus, s_objet_argument_1);
 					free(tampon_lecture);
@@ -1203,9 +1250,8 @@ instruction_read(struct_processus *s_eta
 					return;
 				}
 
-				longueur_effective = fread(tampon_lecture,
-						(size_t) sizeof(unsigned char),
-						(size_t) longueur_enregistrement,
+				longueur_effective = (integer8) fread(tampon_lecture,
+						sizeof(unsigned char), (size_t) longueur_enregistrement,
 						(*descripteur).descripteur_c);
 
 				if (longueur_effective != longueur_enregistrement)
@@ -1230,6 +1276,7 @@ instruction_read(struct_processus *s_eta
 				indicateur_48 = test_cfsf(s_etat_processus, 48);
 				cf(s_etat_processus, 48);
 
+				(*s_etat_processus).type_en_cours = NON;
 				recherche_type(s_etat_processus);
 				free((*s_etat_processus).instruction_courante);
 
@@ -1285,9 +1332,9 @@ instruction_read(struct_processus *s_eta
 					return;
 				}
 
-				if (alsprintf(&commande, "select data from data where "
-						"id = %lld", (*((integer8 *) (*s_objet_argument_2)
-						.objet))) < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"select data from data where id = %lld",
+						(*((integer8 *) (*s_objet_argument_2).objet))) < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1295,49 +1342,64 @@ instruction_read(struct_processus *s_eta
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				
-				switch(sqlite3_step(ppStmt))
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				do
 				{
-					case SQLITE_ROW:
-					{
-						// Résultat attendu
-						break;
-					}
+					ios = sqlite3_step(ppStmt);
 
-					case SQLITE_DONE:
+					switch(ios)
 					{
-						// Aucun enregistrement
-						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+						case SQLITE_ROW:
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
+							// Résultat attendu
+							break;
 						}
 
-						free(commande);
+						case SQLITE_DONE:
+						{
+							// Aucun enregistrement
+							if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
 
-						liberation(s_etat_processus, s_objet_argument_1);
-						liberation(s_etat_processus, s_objet_argument_2);
+							free(commande);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_enregistrement_inexistant;
-						return;
-					}
+							liberation(s_etat_processus, s_objet_argument_1);
+							liberation(s_etat_processus, s_objet_argument_2);
 
-					default:
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_erreur_fichier;
-						return;
+							(*s_etat_processus).erreur_execution =
+									d_ex_enregistrement_inexistant;
+							return;
+						}
+
+						case SQLITE_BUSY:
+						case SQLITE_LOCKED:
+						{
+							nanosleep(&attente, NULL);
+							INCR_GRANULARITE(attente.tv_nsec);
+							break;
+						}
+
+						default:
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
 					}
-				}
+				} while(ios != SQLITE_ROW);
 
 				if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
 				{
@@ -1369,6 +1431,7 @@ instruction_read(struct_processus *s_eta
 				indicateur_48 = test_cfsf(s_etat_processus, 48);
 				cf(s_etat_processus, 48);
 
+				(*s_etat_processus).type_en_cours = NON;
 				recherche_type(s_etat_processus);
 
 				if ((*s_etat_processus).erreur_execution != d_ex)
@@ -1442,8 +1505,8 @@ instruction_read(struct_processus *s_eta
 
 				// Récupération de la position de la clef
 
-				if (alsprintf(&commande, "select key from control "
-						"where id = 1") < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"select key from control where id = 1") < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1451,18 +1514,36 @@ instruction_read(struct_processus *s_eta
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				if (sqlite3_step(ppStmt) != SQLITE_ROW)
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				do
 				{
-					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
-					return;
-				}
+					ios = sqlite3_step(ppStmt);
+
+					if (ios == SQLITE_ROW)
+					{
+						break;
+					}
+					else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
+					{
+						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+				} while(ios != SQLITE_ROW);
 
 				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 				{
@@ -1498,8 +1579,9 @@ instruction_read(struct_processus *s_eta
 
 				// Récupération de l'identifiant de la clef
 
-				if (alsprintf(&commande, "select id from key where key = "
-						"'{ \"%s\" }'", clef_utf8) < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"select id from key where key = '{ \"%s\" }'",
+						clef_utf8) < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1507,49 +1589,65 @@ instruction_read(struct_processus *s_eta
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				switch(sqlite3_step(ppStmt))
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				do
 				{
-					case SQLITE_ROW:
-					{
-						// Résultat attendu : une clef correspond.
-						break;
-					}
+					ios = sqlite3_step(ppStmt);
 
-					case SQLITE_DONE:
+					switch(ios)
 					{
-						// Aucun enregistrement
-						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+						case SQLITE_ROW:
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
+							// Résultat attendu : une clef correspond.
+							break;
 						}
 
-						free(clef_utf8);
-						free(commande);
+						case SQLITE_DONE:
+						{
+							// Aucun enregistrement
+							if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
+
+							free(clef_utf8);
+							free(commande);
 
-						liberation(s_etat_processus, s_objet_argument_1);
-						liberation(s_etat_processus, s_objet_argument_2);
+							liberation(s_etat_processus, s_objet_argument_1);
+							liberation(s_etat_processus, s_objet_argument_2);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_enregistrement_inexistant;
-						return;
-					}
+							(*s_etat_processus).erreur_execution =
+									d_ex_enregistrement_inexistant;
+							return;
+						}
 
-					default:
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_erreur_fichier;
-						return;
+						case SQLITE_BUSY:
+						case SQLITE_LOCKED:
+						{
+							nanosleep(&attente, NULL);
+							INCR_GRANULARITE(attente.tv_nsec);
+							break;
+						}
+
+						default:
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
 					}
-				}
+				} while(ios != SQLITE_ROW);
 
 				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 				{
@@ -1575,7 +1673,8 @@ instruction_read(struct_processus *s_eta
 
 				free(commande);
 
-				if (alsprintf(&commande, "select data from data where "
+				if (alsprintf(s_etat_processus, &commande,
+						"select data from data where "
 						"key_id = %lld order by sequence asc", id) < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1584,7 +1683,7 @@ instruction_read(struct_processus *s_eta
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -1593,6 +1692,9 @@ instruction_read(struct_processus *s_eta
 
 				element = 1;
 
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
 				do
 				{
 					switch(ios = sqlite3_step(ppStmt))
@@ -1639,6 +1741,7 @@ instruction_read(struct_processus *s_eta
 							indicateur_48 = test_cfsf(s_etat_processus, 48);
 							cf(s_etat_processus, 48);
 
+							(*s_etat_processus).type_en_cours = NON;
 							recherche_type(s_etat_processus);
 
 							if ((*s_etat_processus).erreur_execution != d_ex)
@@ -1701,8 +1804,8 @@ instruction_read(struct_processus *s_eta
 									return;
 								}
 
-								if (alsprintf(&tampon2, "{ \"%s\" }",
-										(*s_etat_processus)
+								if (alsprintf(s_etat_processus, &tampon2,
+										"{ \"%s\" }", (*s_etat_processus)
 										.instruction_courante) < 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -1717,6 +1820,7 @@ instruction_read(struct_processus *s_eta
 								indicateur_48 = test_cfsf(s_etat_processus, 48);
 								cf(s_etat_processus, 48);
 
+								(*s_etat_processus).type_en_cours = NON;
 								recherche_type(s_etat_processus);
 
 								if ((*s_etat_processus).erreur_execution
@@ -1771,6 +1875,14 @@ instruction_read(struct_processus *s_eta
 							break;
 						}
 
+						case SQLITE_BUSY:
+						case SQLITE_LOCKED:
+						{
+							nanosleep(&attente, NULL);
+							INCR_GRANULARITE(attente.tv_nsec);
+							break;
+						}
+
 						default:
 						{
 							(*s_etat_processus).erreur_systeme =
@@ -1778,7 +1890,6 @@ instruction_read(struct_processus *s_eta
 							return;
 						}
 					}
-
 				} while(ios != SQLITE_DONE);
 
 				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
@@ -1801,6 +1912,7 @@ instruction_read(struct_processus *s_eta
 				}
 
 				l_element_courant = NULL;
+				l_element_inclus = NULL;
 
 				for(element--; element > 0; element--)
 				{
@@ -1857,12 +1969,390 @@ instruction_read(struct_processus *s_eta
 			/*
 			 * Fichiers non formatés
 			 */
+
+			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
+					== 'S')
+			{
+				/*
+				 * Fichiers séquentiels
+				 *
+				 * Les fichiers séquentiels non formatés contiennent comme
+				 * les fichiers séquentiels formatés leurs enregistrements
+				 * sous la forme de listes les unes derrières les autres.
+				 *
+				 * Le quartet de poids fort du premier octet à lire
+				 * doit donc être égal à 0100. Si ce n'est pas le cas,
+				 * il sera impossible de lire le fichier et on renvoie
+				 * immédiatement une erreur. Si on lit dans le fichier
+				 * la valeur attendue, on récupère la longueur en octet
+				 * de l'enregistrement puis on le lit.
+				 */
+
+				BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
+
+				if ((s_objet_resultat = lecture_fichier_non_formate(
+						s_etat_processus, (*descripteur).descripteur_c, -1,
+						d_faux)) == NULL)
+				{
+					return;
+				}
+
+				if (empilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile),
+						s_objet_resultat) == d_erreur)
+				{
+					return;
+				}
+			}
 		}
 		else
 		{
 			/*
 			 * Fichiers de type FLOW
 			 */
+
+			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
+					== 'S')
+			{
+				/*
+				 * Fichiers séquentiels
+				 */
+
+				BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
+				longueur_enregistrement = 0;
+
+				device = d_faux;
+
+				if ((position_initiale = ftell((*descripteur).descripteur_c))
+						== -1)
+				{
+					if (errno == ESPIPE)
+					{
+						device = d_vrai;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+				}
+
+				l_element_courant_format = (struct_liste_chainee *)
+						(*(*((struct_fichier *) (*s_objet_argument_1).objet))
+						.format).objet;
+				l_element_courant = NULL;
+
+				if ((s_objet_resultat = allocation(s_etat_processus, LST))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				while(l_element_courant_format != NULL)
+				{
+					if ((*(*l_element_courant_format).donnee).type != CHN)
+					{
+						liberation(s_etat_processus, s_objet_argument_1);
+						liberation(s_etat_processus, s_objet_resultat);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_type_argument;
+						return;
+					}
+
+					if ((format_chaine = conversion_majuscule(
+							s_etat_processus, (unsigned char *)
+							(*(*l_element_courant_format).donnee).objet))
+							== NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (strcmp("LINE*(*)", format_chaine) == 0)
+					{
+						format_degenere = d_vrai;
+						format_oriente_ligne = d_vrai;
+					}
+					else
+					{
+						format_oriente_ligne = d_faux;
+
+						if (strncmp("LENGTH*(", format_chaine, 8) != 0)
+						{
+							liberation(s_etat_processus, s_objet_argument_1);
+							liberation(s_etat_processus, s_objet_resultat);
+							free(format_chaine);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_format_fichier;
+							return;
+						}
+
+						longueur = (integer8) strlen(format_chaine);
+
+						if (format_chaine[longueur - 1] != ')')
+						{
+							liberation(s_etat_processus, s_objet_argument_1);
+							liberation(s_etat_processus, s_objet_resultat);
+							free(format_chaine);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_format_fichier;
+							return;
+						}
+
+						format_chaine[longueur] = d_code_fin_chaine;
+
+						if (format_chaine[8] == '*')
+						{
+							format_degenere = d_vrai;
+						}
+						else
+						{
+							// Détermination de la longueur
+							format_degenere = d_faux;
+
+							if (sscanf(&(format_chaine[8]), "%lld", &longueur)
+									!= 1)
+							{
+								liberation(s_etat_processus, s_objet_argument_1);
+								liberation(s_etat_processus, s_objet_resultat);
+								free(format_chaine);
+
+								(*s_etat_processus).erreur_execution =
+										d_ex_erreur_format_fichier;
+								return;
+							}
+						}
+					}
+
+					free(format_chaine);
+					tampon3 = NULL;
+
+					if (format_degenere == d_vrai)
+					{
+						if (device == d_vrai)
+						{
+							longueur_questure = 4096;
+							index = 0;
+
+							if ((tampon3 = malloc(((size_t) longueur_questure) *
+									sizeof(unsigned char))) == NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
+
+							tampon3[index] = d_code_fin_chaine;
+
+							fds[0].fd = fileno((*descripteur).descripteur_c);
+							fds[0].events = POLLIN;
+							fds[0].revents = 0;
+
+							tcgetattr(fileno((*descripteur).descripteur_c),
+									&tc);
+							timeout = 0;
+
+							for(i = 0; vitesses[i] != 0; i++)
+							{
+								if (cfgetispeed(&tc) == vitesses_constantes[i])
+								{
+									// La durée entre deux caractères sur le
+									// périphérique série ne doit pas dépasser
+									// la moitié de la durée de transmission
+									// d'un caractère complet.
+
+									timeout = (int) (((double) 1000) /
+											(((double) vitesses_constantes[i]) /
+											4));
+									break;
+								}
+							}
+						}
+						else
+						{
+							// Évite un warning de gcc.
+							longueur_questure = 0;
+							index = 0;
+							timeout = 0;
+						}
+
+						do
+						{
+							if (device == d_vrai)
+							{
+								if (poll(fds, 1, timeout) == 0)
+								{
+									break;
+								}
+							}
+
+							c = getc((*descripteur).descripteur_c);
+							longueur_enregistrement++;
+
+							if (device == d_vrai)
+							{
+								if (longueur_enregistrement >=
+										longueur_questure)
+								{
+									if ((tampon3 = realloc(tampon3,
+											(size_t) (longueur_questure *= 2)))
+											== NULL)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es_allocation_memoire;
+										return;
+									}
+								}
+
+								tampon3[index++] = (unsigned char) c;
+							}
+
+							if (format_oriente_ligne == d_vrai)
+							{
+								if (c == '\n')
+								{
+									break;
+								}
+							}
+						} while(c != EOF);
+
+						if (device == d_faux)
+						{
+							if (fseek((*descripteur).descripteur_c,
+									(long) position_initiale, SEEK_SET) != 0)
+							{
+								liberation(s_etat_processus,
+										s_objet_argument_1);
+								liberation(s_etat_processus, s_objet_resultat);
+
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
+						}
+					}
+					else
+					{
+						longueur_enregistrement = longueur;
+					}
+
+					if ((device == d_vrai) && (format_degenere == d_vrai))
+					{
+						longueur_effective = longueur_enregistrement;
+						tampon_lecture = tampon3;
+					}
+					else
+					{
+						if ((tampon_lecture = malloc(((size_t)
+								longueur_enregistrement) *
+								sizeof(unsigned char))) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return;
+						}
+
+						longueur_effective = (integer8) fread(tampon_lecture,
+								sizeof(unsigned char),
+								(size_t) longueur_enregistrement,
+								(*descripteur).descripteur_c);
+					}
+
+					if (l_element_courant == NULL)
+					{
+						// Premier maillon de la liste
+						if (((*s_objet_resultat).objet =
+								allocation_maillon(s_etat_processus)) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return;
+						}
+
+						l_element_courant = (*s_objet_resultat).objet;
+					}
+					else
+					{
+						if (((*l_element_courant).suivant =
+								allocation_maillon(s_etat_processus)) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return;
+						}
+
+						l_element_courant = (*l_element_courant).suivant;
+					}
+
+					(*l_element_courant).suivant = NULL;
+
+					if (((*l_element_courant).donnee =
+							allocation(s_etat_processus, CHN)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (format_degenere == d_vrai)
+					{
+						if (device == d_faux)
+						{
+							if (((*(*l_element_courant).donnee).objet =
+								analyse_flux(s_etat_processus, tampon_lecture,
+								longueur_enregistrement - 1)) == NULL)
+							{
+								return;
+							}
+						}
+						else
+						{
+							if (((*(*l_element_courant).donnee).objet =
+								analyse_flux(s_etat_processus, tampon_lecture,
+								longueur_enregistrement)) == NULL)
+							{
+								return;
+							}
+						}
+					}
+					else
+					{
+						if (((*(*l_element_courant).donnee).objet =
+							analyse_flux(s_etat_processus, tampon_lecture,
+							longueur_enregistrement)) == NULL)
+						{
+							return;
+						}
+					}
+
+					free(tampon_lecture);
+
+					l_element_courant_format =
+							(*l_element_courant_format).suivant;
+				}
+
+				if (empilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile),
+						s_objet_resultat) == d_erreur)
+				{
+					return;
+				}
+			}
+			else
+			{
+				liberation(s_etat_processus, s_objet_argument_1);
+
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_type_fichier;
+				return;
+			}
 		}
 	}
 	else if ((*s_objet_argument_1).type == SCK) 
@@ -1901,24 +2391,1182 @@ instruction_read(struct_processus *s_eta
 
 		if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
 		{ // Socket formatée
+			longueur_questure = 4096;
+			longueur_effective = 0;
+			tampon_lecture = NULL;
+
+			attente.tv_sec = 0;
+			attente.tv_nsec = GRANULARITE_us * 1000;
+
+			trame_complete = d_faux;
+			position_initiale = 0;
+			position_finale = 0;
+
+			do
+			{
+				presence_indicateur = d_faux;
+
+				if ((tampon_lecture = realloc(tampon_lecture,
+						((size_t) (longueur_effective + longueur_questure + 1))
+					   	* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+#				ifndef SEMAPHORES_NOMMES
+					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
+				if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_UNIX)
+				{
+					longueur_adresse = sizeof(adresse_unix);
+
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t) (longueur_effective +
+								longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_unix, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET)
+				{
+					longueur_adresse = sizeof(adresse_ipv4);
+
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t) (longueur_effective +
+								longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv4, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET6)
+				{
+#					ifdef IPV6
+					longueur_adresse = sizeof(adresse_ipv6);
+					
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t) (longueur_effective +
+								longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv6, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+#					else
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Attention : Support du protocole"
+								" IPv6 indisponible\n");
+					}
+					else
+					{
+						printf("+++Warning : IPv6 support "
+								"unavailable\n");
+					}
+
+					longueur_adresse = 0;
+					longueur_effective = 0;
+					ios = 0;
+#					endif
+				}
+				else
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#					else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) != 0)
+#					endif
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+					}
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+
+				if (ios <= 0)
+				{
+					nanosleep(&attente, NULL);
+					INCR_GRANULARITE(attente.tv_nsec);
+				}
+				else
+				{
+					attente.tv_sec = 0;
+					attente.tv_nsec = GRANULARITE_us * 1000;
+				}
+
+				scrutation_injection(s_etat_processus);
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+					if (ios >= 0)
+					{
+						longueur_effective = ios;
+					}
+
+					break;
+				}
+
+				// Une donnée a été reçue.
+
+				if (ios >= 0)
+				{
+					longueur_effective = ios;
+					position_initiale = 0;
+					presence_indicateur = d_faux;
+
+					do
+					{
+						if (tampon_lecture[position_initiale] == '{')
+						{
+							presence_indicateur = d_vrai;
+							break;
+						}
+
+						position_initiale++;
+					} while(position_initiale < longueur_effective);
+
+					if (presence_indicateur == d_vrai)
+					{
+						position_finale = position_initiale + 1;
+						presence_chaine = d_faux;
+						presence_indicateur = d_faux;
+						niveau = 1;
+
+						while(position_finale < longueur_effective)
+						{
+							caractere = tampon_lecture[position_finale];
+
+							if (caractere == '"')
+							{
+								if (position_finale > 0)
+								{
+									if (tampon_lecture[position_finale - 1]
+											!= '\\')
+									{
+										presence_chaine = (presence_chaine ==
+												d_vrai) ? d_faux : d_vrai;
+									}
+								}
+								else
+								{
+									presence_chaine =
+											(presence_chaine == d_vrai)
+											? d_faux : d_vrai;
+								}
+							}
+							else
+							{
+								if (presence_chaine == d_faux)
+								{
+									if (caractere == '{')
+									{
+										niveau++;
+									}
+									else if (caractere == '}')
+									{
+										niveau--;
+									}
+								}
+							}
+
+							if (niveau == 0)
+							{
+								presence_indicateur = d_vrai;
+								trame_complete = d_vrai;
+								break;
+							}
+
+							position_finale++;
+						}
+					}
+
+					// On retire une trame du buffer.
+
+					if (trame_complete == d_vrai)
+					{
+						if ((*((struct_socket *) (*s_objet_argument_1).objet))
+								.domaine == PF_UNIX)
+						{
+							do
+							{
+								longueur_adresse = sizeof(adresse_unix);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture,
+										(size_t) longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_unix, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+						}
+						else if ((*((struct_socket *) (*s_objet_argument_1)
+								.objet)).domaine == PF_INET)
+						{
+							do
+							{
+								longueur_adresse = sizeof(adresse_ipv4);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture,
+										(size_t) longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_ipv4, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+						}
+						else if ((*((struct_socket *) (*s_objet_argument_1)
+								.objet)) .domaine == PF_INET6)
+						{
+#							ifdef IPV6
+							do
+							{
+								longueur_adresse = sizeof(adresse_ipv6);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture,
+										(size_t) longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_ipv6, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+#							else
+							if ((*s_etat_processus).langue == 'F')
+							{
+								printf("+++Attention : Support du protocole"
+										" IPv6 indisponible\n");
+							}
+							else
+							{
+								printf("+++Warning : IPv6 support "
+										"unavailable\n");
+							}
+
+#							endif
+						}
+
+						longueur_effective = ios;
+					}
+					else
+					{
+						// Si on a lu toute une trame et qu'on n'a pas
+						// réussi à en trouver la structure, on remonte
+						// une erreur de syntaxe.
+
+						if (longueur_effective == ios)
+						{
+							if ((*((struct_socket *) (*s_objet_argument_1)
+									.objet)).domaine == PF_UNIX)
+							{
+								do
+								{
+									longueur_adresse = sizeof(adresse_unix);
+									recvfrom((*((struct_socket *)
+											(*s_objet_argument_1).objet))
+											.socket, tampon_lecture,
+											(size_t) longueur_effective,
+											0, (struct sockaddr *)
+											&adresse_unix, &longueur_adresse);
+								} while((ios == -1) && (errno == EINTR));
+							}
+							else if ((*((struct_socket *) (*s_objet_argument_1)
+									.objet)).domaine == PF_INET)
+							{
+								do
+								{
+									longueur_adresse = sizeof(adresse_ipv4);
+									recvfrom((*((struct_socket *)
+											(*s_objet_argument_1).objet))
+											.socket, tampon_lecture,
+											(size_t) longueur_effective,
+											0, (struct sockaddr *)
+											&adresse_ipv4, &longueur_adresse);
+								} while((ios == -1) && (errno == EINTR));
+							}
+							else if ((*((struct_socket *) (*s_objet_argument_1)
+									.objet)) .domaine == PF_INET6)
+							{
+#								ifdef IPV6
+								do
+								{
+									longueur_adresse = sizeof(adresse_ipv6);
+									recvfrom((*((struct_socket *)
+											(*s_objet_argument_1).objet))
+											.socket, tampon_lecture,
+											(size_t) longueur_effective,
+											0, (struct sockaddr *)
+											&adresse_ipv6, &longueur_adresse);
+								} while((ios == -1) && (errno == EINTR));
+#								else
+								if ((*s_etat_processus).langue == 'F')
+								{
+									printf("+++Attention : Support du protocole"
+											" IPv6 indisponible\n");
+								}
+								else
+								{
+									printf("+++Warning : IPv6 support "
+											"unavailable\n");
+								}
+
+#								endif
+							}
+
+							liberation(s_etat_processus, s_objet_argument_1);
+							free(tampon_lecture);
+
+							(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+							return;
+						}
+					}
+				}
+
+#				ifndef SEMAPHORES_NOMMES
+					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#				endif
+				{
+					if (errno == EINTR)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+				}
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+
+					/*
+					 * Si le père tue le processus courant grâce au signal
+					 * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
+					 * correspond à l'utilisation de STOP sur le processus
+					 * en cours. La variable longueur_effective vaut '-1'.
+					 */
+
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+					return;
+				}
+
+				if (longueur_effective == -1)
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+			} while(trame_complete == d_faux);
+
+			tampon_lecture[++position_finale] = d_code_fin_chaine;
+			tampon = (*s_etat_processus).instruction_courante;
+			(*s_etat_processus).instruction_courante = tampon_lecture;
+
+			indicateur_48 = test_cfsf(s_etat_processus, 48);
+			cf(s_etat_processus, 48);
+
+			(*s_etat_processus).type_en_cours = NON;
+			recherche_type(s_etat_processus);
+
+			if ((*s_etat_processus).erreur_execution != d_ex)
+			{
+				(*s_etat_processus).instruction_courante = tampon;
+				free(tampon_lecture);
+				
+				if (indicateur_48 == d_vrai)
+				{
+					sf(s_etat_processus, 48);
+				}
+				else
+				{
+					cf(s_etat_processus, 48);
+				}
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+					(*s_etat_processus).erreur_execution = d_ex;
+				}
+
+				liberation(s_etat_processus, s_objet_argument_1);
+				return;
+			}
+
+			if (indicateur_48 == d_vrai)
+			{
+				sf(s_etat_processus, 48);
+			}
+			else
+			{
+				cf(s_etat_processus, 48);
+			}
+
+			(*s_etat_processus).instruction_courante = tampon;
+
+			/*
+			 * Création de la liste de sortie
+			 */
+
+			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					&s_objet_type) == d_erreur)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+				return;
+			}
+
+			if ((s_objet_resultat = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*s_objet_resultat).objet =
+					allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.donnee = s_objet_type;
+
+			if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.suivant = allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.suivant = NULL;
+
+			if ((s_objet_adresse = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.donnee = s_objet_adresse;
+
+			/*
+			 * Les informations concernant la cible sont valides si
+			 * la socket est non connectée et des domaines INET ou INET6.
+			 * Dans tous les autres cas, on renvoie une liste vide.
+			 */
+
+			if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
+					== PF_UNIX) || (strcmp((*((struct_socket *)
+					(*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
+					(strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
+					.type, "SEQUENTIAL DATAGRAM") == 0))
+			{
+				(*s_objet_adresse).objet = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET)
+			{
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 4;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(4 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[0] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[1] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[2] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[3] =
+						ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv4.sin_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET6)
+			{
+#				ifdef IPV6
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 16;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(16 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				for(i = 0; i < 16; i++)
+				{
+					((integer8 *) (*((struct_vecteur *)
+							(*(*((struct_liste_chainee *) (*s_objet_adresse)
+							.objet)).donnee).objet)).tableau)[0] =
+							adresse_ipv6.sin6_addr.s6_addr[i];
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv6.sin6_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+#				else
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#				endif
+			}
+			else
+			{
+				longueur_adresse = 0;
+				recvfrom((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						(size_t) position_finale, MSG_DONTWAIT,
+						NULL, &longueur_adresse);
+			}
+
+			free(tampon_lecture);
+
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
+		}
+		else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
+				== 'Y')
+		{ // socket non formatée
+			longueur_questure = 4096;
+			longueur_effective = 0;
+			tampon_lecture = NULL;
+
+			attente.tv_sec = 0;
+			attente.tv_nsec = GRANULARITE_us * 1000;
+
+			trame_complete = d_faux;
+			position_initiale = 0;
+			position_finale = 0;
+
+			do
+			{
+				presence_indicateur = d_faux;
+
+				if ((tampon_lecture = realloc(tampon_lecture,
+						((size_t) (longueur_effective + longueur_questure) + 1)
+					   	* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+#				ifndef SEMAPHORES_NOMMES
+					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
+				if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_UNIX)
+				{
+					longueur_adresse = sizeof(adresse_unix);
+
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t)
+								(longueur_effective + longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_unix, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET)
+				{
+					longueur_adresse = sizeof(adresse_ipv4);
+
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t)
+								(longueur_effective + longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv4, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET6)
+				{
+#					ifdef IPV6
+					longueur_adresse = sizeof(adresse_ipv6);
+					
+					do
+					{
+						ios = (int) recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, (size_t)
+								(longueur_effective + longueur_questure),
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv6, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+#					else
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Attention : Support du protocole"
+								" IPv6 indisponible\n");
+					}
+					else
+					{
+						printf("+++Warning : IPv6 support "
+								"unavailable\n");
+					}
+
+					longueur_adresse = 0;
+					longueur_effective = 0;
+					ios = 0;
+#					endif
+				}
+				else
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#					else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) != 0)
+#					endif
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+					}
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+
+				if (ios <= 0)
+				{
+					nanosleep(&attente, NULL);
+					INCR_GRANULARITE(attente.tv_nsec);
+				}
+				else
+				{
+					attente.tv_sec = 0;
+					attente.tv_nsec = GRANULARITE_us * 1000;
+				}
+
+				scrutation_injection(s_etat_processus);
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+					if (ios >= 0)
+					{
+						longueur_effective += ios;
+					}
+
+					break;
+				}
+
+				// Une donnée a été reçue.
+
+				if (ios == (longueur_effective + longueur_questure))
+				{
+					longueur_effective = ios;
+					position_initiale = 0;
+					presence_indicateur = d_faux;
+				}
+				else if (ios > 0)
+				{
+					// On retire une trame du buffer.
+
+					if ((*((struct_socket *) (*s_objet_argument_1).objet))
+							.domaine == PF_UNIX)
+					{
+						do
+						{
+							longueur_adresse = sizeof(adresse_unix);
+							recvfrom((*((struct_socket *)
+									(*s_objet_argument_1).objet)).socket,
+									tampon_lecture, (size_t) longueur_effective,
+									0, (struct sockaddr *)
+									&adresse_unix, &longueur_adresse);
+						} while((ios == -1) && (errno == EINTR));
+					}
+					else if ((*((struct_socket *) (*s_objet_argument_1)
+							.objet)).domaine == PF_INET)
+					{
+						do
+						{
+							longueur_adresse = sizeof(adresse_ipv4);
+							recvfrom((*((struct_socket *)
+									(*s_objet_argument_1).objet)).socket,
+									tampon_lecture, (size_t) longueur_effective,
+									0, (struct sockaddr *)
+									&adresse_ipv4, &longueur_adresse);
+						} while((ios == -1) && (errno == EINTR));
+					}
+					else if ((*((struct_socket *) (*s_objet_argument_1)
+							.objet)) .domaine == PF_INET6)
+					{
+#						ifdef IPV6
+						do
+						{
+							longueur_adresse = sizeof(adresse_ipv6);
+							recvfrom((*((struct_socket *)
+									(*s_objet_argument_1).objet)).socket,
+									tampon_lecture, (size_t) longueur_effective,
+									0, (struct sockaddr *)
+									&adresse_ipv6, &longueur_adresse);
+						} while((ios == -1) && (errno == EINTR));
+#						else
+						if ((*s_etat_processus).langue == 'F')
+						{
+							printf("+++Attention : Support du protocole"
+									" IPv6 indisponible\n");
+						}
+						else
+						{
+							printf("+++Warning : IPv6 support "
+									"unavailable\n");
+						}
+#						endif
+					}
+
+					longueur_effective = ios;
+					trame_complete = d_vrai;
+				}
+
+#				ifndef SEMAPHORES_NOMMES
+					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#				endif
+				{
+					if (errno == EINTR)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+				}
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+
+					/*
+					 * Si le père tue le processus courant grâce au signal
+					 * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
+					 * correspond à l'utilisation de STOP sur le processus
+					 * en cours. La variable longueur_effective vaut '-1'.
+					 */
+
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+					return;
+				}
+
+				if (longueur_effective == -1)
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+			} while(trame_complete == d_faux);
+
+			/*
+			 * Création de la liste de sortie
+			 */
+
+			ptr = tampon_lecture;
+
+			if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
+					&ptr, longueur_effective, d_faux)) == NULL)
+			{
+				free(tampon_lecture);
+
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+				return;
+			}
+
+			if ((s_objet_resultat = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*s_objet_resultat).objet =
+					allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.donnee = s_objet_type;
+
+			if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.suivant = allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.suivant = NULL;
+
+			if ((s_objet_adresse = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.donnee = s_objet_adresse;
+
+			/*
+			 * Les informations concernant la cible sont valides si
+			 * la socket est non connectée et des domaines INET ou INET6.
+			 * Dans tous les autres cas, on renvoie une liste vide.
+			 */
+
+			if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
+					== PF_UNIX) || (strcmp((*((struct_socket *)
+					(*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
+					(strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
+					.type, "SEQUENTIAL DATAGRAM") == 0))
+			{
+				(*s_objet_adresse).objet = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET)
+			{
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 4;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(4 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[0] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[1] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[2] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[3] =
+						ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv4.sin_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET6)
+			{
+#				ifdef IPV6
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 16;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(16 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				for(i = 0; i < 16; i++)
+				{
+					((integer8 *) (*((struct_vecteur *)
+							(*(*((struct_liste_chainee *) (*s_objet_adresse)
+							.objet)).donnee).objet)).tableau)[0] =
+							adresse_ipv6.sin6_addr.s6_addr[i];
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv6.sin6_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+#				else
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#				endif
+			}
+			else
+			{
+				longueur_adresse = 0;
+				recvfrom((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						(size_t) position_finale, MSG_DONTWAIT,
+						NULL, &longueur_adresse);
+			}
+
+			free(tampon_lecture);
+
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
+		}
+		else
+		{ // FLOW
 			longueur_questure = 256;
 
 			do
 			{
-				if ((tampon_lecture = malloc((longueur_questure + 1) *
-						sizeof(unsigned char))) == NULL)
+				if ((tampon_lecture = malloc((((size_t) longueur_questure) + 1)
+						* sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
 					return;
 				}
 
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#				ifndef SEMAPHORES_NOMMES
+					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
 
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
 				for(;;)
 				{
 					if ((*((struct_socket *) (*s_objet_argument_1).objet))
@@ -1927,7 +3575,8 @@ instruction_read(struct_processus *s_eta
 						longueur_adresse = sizeof(adresse_unix);
 						longueur_effective = recvfrom((*((struct_socket *)
 								(*s_objet_argument_1).objet)).socket,
-								tampon_lecture, longueur_questure,
+								tampon_lecture, (long unsigned int)
+								longueur_questure,
 								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 								&adresse_unix, &longueur_adresse);
 					}
@@ -1937,27 +3586,50 @@ instruction_read(struct_processus *s_eta
 						longueur_adresse = sizeof(adresse_ipv4);
 						longueur_effective = recvfrom((*((struct_socket *)
 								(*s_objet_argument_1).objet)).socket,
-								tampon_lecture, longueur_questure,
+								tampon_lecture, (long unsigned int)
+								longueur_questure,
 								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 								&adresse_ipv4, &longueur_adresse);
 					}
 					else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 							.domaine == PF_INET6)
 					{
+#						ifdef IPV6
 						longueur_adresse = sizeof(adresse_ipv6);
 						longueur_effective = recvfrom((*((struct_socket *)
 								(*s_objet_argument_1).objet)).socket,
-								tampon_lecture, longueur_questure,
+								tampon_lecture, (long unsigned int)
+								longueur_questure,
 								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 								&adresse_ipv6, &longueur_adresse);
+#						else
+						if ((*s_etat_processus).langue == 'F')
+						{
+							printf("+++Attention : Support du protocole"
+									" IPv6 indisponible\n");
+						}
+						else
+						{
+							printf("+++Warning : IPv6 support "
+									"unavailable\n");
+						}
+
+						longueur_adresse = 0;
+						longueur_effective = 0;
+#						endif
 					}
 					else
 					{
 						free(tampon_lecture);
 						liberation(s_etat_processus, s_objet_argument_1);
 
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -1975,6 +3647,7 @@ instruction_read(struct_processus *s_eta
 					if (longueur_effective < 0)
 					{
 						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
 						scrutation_injection(s_etat_processus);
 					}
 
@@ -1985,8 +3658,11 @@ instruction_read(struct_processus *s_eta
 					}
 				}
 
-				while(sem_wait(&((*s_etat_processus).semaphore_fork))
-						== -1)
+#				ifndef SEMAPHORES_NOMMES
+					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 				{
 					if (errno != EINTR)
 					{
@@ -2020,120 +3696,66 @@ instruction_read(struct_processus *s_eta
 					return;
 				}
 
-				position_initiale = 0;
-				presence_indicateur = d_faux;
-
-				do
+				if (longueur_effective == longueur_questure)
 				{
-					if (tampon_lecture[position_initiale] == '{')
-					{
-						presence_indicateur = d_vrai;
-						break;
-					}
-
-					position_initiale++;
-				} while(position_initiale < longueur_effective);
+					free(tampon_lecture);
+					longueur_questure *= 2;
+				}
+			} while(longueur_effective == longueur_questure);
 
+			longueur_enregistrement = 1;
 
-				if (presence_indicateur == d_vrai)
+			for(i = 0; i < longueur_effective; i++)
+			{
+				if (isprint(tampon_lecture[i]) != 0)
 				{
-					position_finale = position_initiale + 1;
-					presence_chaine = d_faux;
-					presence_indicateur = d_faux;
-					niveau = 1;
-
-					while(position_finale < longueur_effective)
-					{
-						caractere = tampon_lecture[position_finale];
-
-						if (caractere == '"')
-						{
-							presence_chaine = (presence_chaine == d_vrai)
-									? d_faux : d_vrai;
-						}
-						else
-						{
-							if (presence_chaine == d_faux)
-							{
-								if (caractere == '{')
-								{
-									niveau++;
-								}
-								else if (caractere == '}')
-								{
-									niveau--;
-								}
-							}
-						}
-
-						if (niveau == 0)
-						{
-							presence_indicateur = d_vrai;
-							break;
-						}
-
-						position_finale++;
-					}
+					longueur_enregistrement += 4;
 				}
-
-				if (presence_indicateur == d_faux)
+				else
 				{
-					if (longueur_effective < longueur_questure)
-					{
-						liberation(s_etat_processus, s_objet_argument_1);
-						free(tampon_lecture);
-
-						(*s_etat_processus).erreur_execution =
-								d_ex_fin_de_fichier_atteinte;
-						return;
-					}
-
-					free(tampon_lecture);
-					longueur_questure *= 2;
+					longueur_enregistrement++;
 				}
-			} while(presence_indicateur == d_faux);
-
-			tampon_lecture[++position_finale] = d_code_fin_chaine;
-			tampon = (*s_etat_processus).instruction_courante;
-			(*s_etat_processus).instruction_courante = &(tampon_lecture
-					[position_initiale]);
-
-			indicateur_48 = test_cfsf(s_etat_processus, 48);
-			cf(s_etat_processus, 48);
+			}
 
-			recherche_type(s_etat_processus);
+			/*
+			 * Création de la liste de sortie
+			 */
 
-			if ((*s_etat_processus).erreur_execution != d_ex)
+			if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
 			{
-				(*s_etat_processus).instruction_courante = tampon;
-				free(tampon_lecture);
-				
-				liberation(s_etat_processus, s_objet_argument_1);
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			if (indicateur_48 == d_vrai)
-			{
-				sf(s_etat_processus, 48);
-			}
-			else
+			if (((*s_objet_type).objet = malloc((size_t) longueur_enregistrement
+					* sizeof(unsigned char))) == NULL)
 			{
-				cf(s_etat_processus, 48);
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
 			}
 
-			(*s_etat_processus).instruction_courante = tampon;
-
-			/*
-			 * Création de la liste de sortie
-			 */
+			ptr = (*s_objet_type).objet;
 
-			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-					&s_objet_type) == d_erreur)
+			for(i = 0; i < longueur_effective; i++)
 			{
-				(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-				return;
+				if (isprint(tampon_lecture[i]) != 0)
+				{
+					(*ptr) = tampon_lecture[i];
+					ptr++;
+				}
+				else
+				{
+					(*ptr) = '\\';
+					ptr++;
+					(*ptr) = 'x';
+					ptr++;
+					sprintf(ptr, "%02X", tampon_lecture[i]);
+					ptr += 2;
+				}
 			}
 
+			(*ptr) = d_code_fin_chaine;
+
 			if ((s_objet_resultat = allocation(s_etat_processus, LST))
 					== NULL)
 			{
@@ -2173,7 +3795,8 @@ instruction_read(struct_processus *s_eta
 
 			/*
 			 * Les informations concernant la cible sont valides si
-			 * la socket est non connectée et des domaines INET ou INET6.
+			 * la socket est non connectée et que les domaines sont
+			 * INET ou INET6.
 			 * Dans tous les autres cas, on renvoie une liste vide.
 			 */
 
@@ -2183,10 +3806,12 @@ instruction_read(struct_processus *s_eta
 					(strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
 					.type, "SEQUENTIAL DATAGRAM") == 0))
 			{
+				// POSITION_FINALE peut être utilisée sans être initialisée !
+				// virer position_finale pour longueur_effective
 				longueur_adresse = 0;
 				recvfrom((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, tampon_lecture,
-						position_finale, MSG_DONTWAIT,
+						(long unsigned int) longueur_effective, MSG_DONTWAIT,
 						NULL, &longueur_adresse);
 
 				(*s_objet_adresse).objet = NULL;
@@ -2197,7 +3822,7 @@ instruction_read(struct_processus *s_eta
 				longueur_adresse = sizeof(adresse_ipv4);
 				recvfrom((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, tampon_lecture,
-						position_finale, MSG_DONTWAIT,
+						(long unsigned int) longueur_effective, MSG_DONTWAIT,
 						(struct sockaddr *) &adresse_ipv4, &longueur_adresse);
 
 				if (((*s_objet_adresse).objet =
@@ -2273,10 +3898,11 @@ instruction_read(struct_processus *s_eta
 			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 					.domaine == PF_INET6)
 			{
+#				ifdef IPV6
 				longueur_adresse = sizeof(adresse_ipv6);
 				recvfrom((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, tampon_lecture,
-						position_finale, MSG_DONTWAIT,
+						(long unsigned int) longueur_effective, MSG_DONTWAIT,
 						(struct sockaddr *) &adresse_ipv6, &longueur_adresse);
 
 				if (((*s_objet_adresse).objet =
@@ -2339,13 +3965,25 @@ instruction_read(struct_processus *s_eta
 
 				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 						.suivant).suivant = NULL;
+#				else
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#				endif
 			}
 			else
 			{
 				longueur_adresse = 0;
 				recvfrom((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, tampon_lecture,
-						position_finale, MSG_DONTWAIT,
+						(long unsigned int) longueur_effective, MSG_DONTWAIT,
 						NULL, &longueur_adresse);
 			}
 
@@ -2357,10 +3995,6 @@ instruction_read(struct_processus *s_eta
 				return;
 			}
 		}
-		else
-		{
-			/* FLOW ou UNFORMATTED */
-		}
 	}
 	else
 	{