--- rpl/src/instructions_r4.c	2010/03/08 08:34:15	1.7
+++ rpl/src/instructions_r4.c	2011/09/26 15:57:15	1.45
@@ -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.4
+  Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -848,10 +848,18 @@ instruction_read(struct_processus *s_eta
 {
 	const char						*queue;
 
+	int								c;
+	int								ios;
+
+	integer8						element;
+	integer8						id;
+	integer8						position_clef;
+
 	logical1						indicateur_48;
 	logical1						presence_chaine;
 	logical1						presence_indicateur;
 
+	long							i;
 	long							longueur_effective;
 	long							longueur_enregistrement;
 	long							longueur_questure;
@@ -868,12 +876,17 @@ instruction_read(struct_processus *s_eta
 
 	struct sockaddr_un				adresse_unix;
 	struct sockaddr_in				adresse_ipv4;
+#	ifdef IPV6
 	struct sockaddr_in6				adresse_ipv6;
+#	endif
 
 	struct timespec					attente;
 
 	struct_descripteur_fichier		*descripteur;
 
+	struct_liste_chainee			*l_element_courant;
+	struct_liste_chainee			*l_element_inclus;
+
 	struct_objet					*s_objet_adresse;
 	struct_objet					*s_objet_argument_1;
 	struct_objet					*s_objet_argument_2;
@@ -881,17 +894,15 @@ instruction_read(struct_processus *s_eta
 	struct_objet					*s_objet_type;
 
 	unsigned char					caractere;
+	unsigned char					*clef_utf8;
 	unsigned char					*commande;
+	unsigned char					*ptr;
 	unsigned char					*tampon_lecture;
 	unsigned char					*tampon;
-
-	unsigned long					i;
+	unsigned char					*tampon2;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
-	attente.tv_sec = 0;
-	attente.tv_nsec = GRANULARITE_us * 1000;
-
 	if ((*s_etat_processus).affichage_arguments == 'Y')
 	{
 		printf("\n  READ ");
@@ -907,7 +918,7 @@ instruction_read(struct_processus *s_eta
 
 		printf("    1: %s, %s\n\n", d_FCH, d_SCK);
 
-		printf("    1: %s, %s\n", d_INT, d_CHN);
+		printf("    2: %s, %s\n", d_INT, d_CHN);
 		printf("    1: %s\n", d_FCH);
 		return;
 	}
@@ -1290,7 +1301,6 @@ instruction_read(struct_processus *s_eta
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
-
 				
 				switch(sqlite3_step(ppStmt))
 				{
@@ -1371,13 +1381,13 @@ instruction_read(struct_processus *s_eta
 						cf(s_etat_processus, 48);
 					}
 
-					(*s_etat_processus).instruction_courante = tampon;
-					
 					liberation(s_etat_processus, s_objet_argument_1);
 					liberation(s_etat_processus, s_objet_argument_2);
 
 					free((*s_etat_processus).instruction_courante);
 					free(commande);
+
+					(*s_etat_processus).instruction_courante = tampon;
 					return;
 				}
 
@@ -1410,6 +1420,435 @@ instruction_read(struct_processus *s_eta
 			}
 			else
 			{
+				BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
+
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_argument_2) == d_erreur)
+				{
+					(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+					return;
+				}
+
+				if ((*s_objet_argument_2).type != CHN)
+				{
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				// Récupération de la position de la clef
+
+				if (alsprintf(&commande, "select key from control "
+						"where id = 1") < 0)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
+						commande, strlen(commande), &ppStmt, &queue)
+						!= SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				if (sqlite3_step(ppStmt) != SQLITE_ROW)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				position_clef = sqlite3_column_int64(ppStmt, 0);
+
+				if (sqlite3_step(ppStmt) != SQLITE_DONE)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				free(commande);
+
+				if ((clef_utf8 = transliteration(s_etat_processus,
+						(unsigned char *) (*s_objet_argument_2).objet,
+						d_locale, "UTF-8")) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+
+					return;
+				}
+
+				// Récupération de l'identifiant de la clef
+
+				if (alsprintf(&commande, "select id from key where key = "
+						"'{ \"%s\" }'", clef_utf8) < 0)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
+						commande, strlen(commande), &ppStmt, &queue)
+						!= SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				switch(sqlite3_step(ppStmt))
+				{
+					case SQLITE_ROW:
+					{
+						// Résultat attendu : une clef correspond.
+						break;
+					}
+
+					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);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_enregistrement_inexistant;
+						return;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+				}
+
+				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
+				{
+					free(clef_utf8);
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				id = sqlite3_column_int64(ppStmt, 0);
+
+				if (sqlite3_step(ppStmt) != SQLITE_DONE)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_erreur_fichier;
+					return;
+				}
+
+				free(commande);
+
+				if (alsprintf(&commande, "select data from data where "
+						"key_id = %lld order by sequence asc", id) < 0)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
+						commande, strlen(commande), &ppStmt, &queue)
+						!= SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				element = 1;
+
+				do
+				{
+					switch(ios = sqlite3_step(ppStmt))
+					{
+						case SQLITE_ROW:
+						{
+							// Donnée supplémentaire
+
+							if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
+
+							tampon = (*s_etat_processus).instruction_courante;
+
+							if ((tampon_lecture = (unsigned char *)
+									sqlite3_column_text(ppStmt, 0)) == NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
+
+							if (((*s_etat_processus).instruction_courante =
+									transliteration(s_etat_processus,
+									tampon_lecture,
+									"UTF-8", d_locale)) == NULL)
+							{
+								(*s_etat_processus).instruction_courante =
+										tampon;
+
+								liberation(s_etat_processus,
+										s_objet_argument_1);
+								liberation(s_etat_processus,
+										s_objet_argument_2);
+
+								free(commande);
+								free(clef_utf8);
+								return;
+							}
+
+							indicateur_48 = test_cfsf(s_etat_processus, 48);
+							cf(s_etat_processus, 48);
+
+							recherche_type(s_etat_processus);
+
+							if ((*s_etat_processus).erreur_execution != d_ex)
+							{
+								if (indicateur_48 == d_vrai)
+								{
+									sf(s_etat_processus, 48);
+								}
+								else
+								{
+									cf(s_etat_processus, 48);
+								}
+
+								liberation(s_etat_processus,
+										s_objet_argument_1);
+								liberation(s_etat_processus,
+										s_objet_argument_2);
+
+								free((*s_etat_processus).instruction_courante);
+								free(commande);
+								free(clef_utf8);
+
+								(*s_etat_processus).instruction_courante =
+										tampon;
+								return;
+							}
+
+							if (indicateur_48 == d_vrai)
+							{
+								sf(s_etat_processus, 48);
+							}
+							else
+							{
+								cf(s_etat_processus, 48);
+							}
+
+							free((*s_etat_processus).instruction_courante);
+							(*s_etat_processus).instruction_courante = tampon;
+
+							element++;
+
+							// Inscription de la clef
+
+							if (element == position_clef)
+							{
+								if (((*s_etat_processus).instruction_courante =
+										transliteration(s_etat_processus,
+										clef_utf8, "UTF-8", d_locale)) == NULL)
+								{
+									(*s_etat_processus).instruction_courante =
+											tampon;
+
+									liberation(s_etat_processus,
+											s_objet_argument_1);
+									liberation(s_etat_processus,
+											s_objet_argument_2);
+
+									free(commande);
+									free(clef_utf8);
+									return;
+								}
+
+								if (alsprintf(&tampon2, "{ \"%s\" }",
+										(*s_etat_processus)
+										.instruction_courante) < 0)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									return;
+								}
+
+								free((*s_etat_processus).instruction_courante);
+								(*s_etat_processus).instruction_courante
+										= tampon2;
+
+								indicateur_48 = test_cfsf(s_etat_processus, 48);
+								cf(s_etat_processus, 48);
+
+								recherche_type(s_etat_processus);
+
+								if ((*s_etat_processus).erreur_execution
+										!= d_ex)
+								{
+									if (indicateur_48 == d_vrai)
+									{
+										sf(s_etat_processus, 48);
+									}
+									else
+									{
+										cf(s_etat_processus, 48);
+									}
+
+									liberation(s_etat_processus,
+											s_objet_argument_1);
+									liberation(s_etat_processus,
+											s_objet_argument_2);
+
+									free((*s_etat_processus)
+											.instruction_courante);
+									free(commande);
+									free(clef_utf8);
+
+									(*s_etat_processus).instruction_courante =
+											tampon;
+									return;
+								}
+
+								if (indicateur_48 == d_vrai)
+								{
+									sf(s_etat_processus, 48);
+								}
+								else
+								{
+									cf(s_etat_processus, 48);
+								}
+
+								free((*s_etat_processus).instruction_courante);
+								(*s_etat_processus).instruction_courante =
+										tampon;
+
+								element++;
+							}
+
+							break;
+						}
+
+						case SQLITE_DONE:
+						{
+							// Fin de la liste
+							break;
+						}
+
+						default:
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+					}
+
+				} while(ios != SQLITE_DONE);
+
+				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				free(commande);
+				free(clef_utf8);
+
+				liberation(s_etat_processus, s_objet_argument_2);
+
+				if ((s_objet_resultat = allocation(s_etat_processus, LST))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				l_element_courant = NULL;
+				l_element_inclus = NULL;
+
+				for(element--; element > 0; element--)
+				{
+					if (depilement(s_etat_processus, &((*s_etat_processus)
+							.l_base_pile), &s_objet_argument_2) == d_erreur)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+
+					if ((*s_objet_argument_2).type != LST)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+
+					l_element_inclus = (*s_objet_argument_2).objet;
+
+					if (l_element_inclus != NULL)
+					{
+						while(l_element_inclus != NULL)
+						{
+							if ((*l_element_inclus).suivant == NULL)
+							{
+								(*l_element_inclus).suivant = l_element_courant;
+								break;
+							}
+
+							l_element_inclus = (*l_element_inclus).suivant;
+						}
+
+						l_element_courant = (*s_objet_argument_2).objet;
+						(*s_objet_argument_2).objet = NULL;
+					}
+
+					liberation(s_etat_processus, s_objet_argument_2);
+				}
+
+				(*s_objet_resultat).objet = l_element_inclus;
+
+				if (empilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile),
+						s_objet_resultat) == d_erreur)
+				{
+					return;
+				}
 			}
 		}
 		else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
@@ -1424,6 +1863,141 @@ instruction_read(struct_processus *s_eta
 			/*
 			 * 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;
+
+				if ((position_initiale = ftell((*descripteur).descripteur_c))
+						== -1)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				do
+				{
+					c = getc((*descripteur).descripteur_c);
+					longueur_enregistrement++;
+				} while((c != '\n') && (c != EOF));
+
+				if (fseek((*descripteur).descripteur_c, position_initiale,
+						SEEK_SET) != 0)
+				{
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				if ((tampon_lecture = malloc((longueur_enregistrement + 1)
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				longueur_effective = fread(tampon_lecture,
+						(size_t) sizeof(unsigned char),
+						(size_t) longueur_enregistrement,
+						(*descripteur).descripteur_c);
+
+				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))
+						.suivant = NULL;
+
+				if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
+						.donnee = allocation(s_etat_processus, CHN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				longueur_enregistrement = 1;
+
+				for(i = 0; i < longueur_effective; i++)
+				{
+					if (isprint(tampon_lecture[i]) != 0)
+					{
+						longueur_enregistrement += 4;
+					}
+					else
+					{
+						longueur_enregistrement++;
+					}
+				}
+
+				if ((tampon = malloc(longueur_enregistrement *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				ptr = tampon;
+
+				for(i = 0; i < longueur_effective; i++)
+				{
+					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;
+				free(tampon_lecture);
+				((*(*((struct_liste_chainee *) (*s_objet_resultat).objet))
+						.donnee)).objet = tampon;
+
+				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) 
@@ -1474,12 +2048,19 @@ instruction_read(struct_processus *s_eta
 					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))
@@ -1505,27 +2086,42 @@ 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);
 						longueur_effective = recvfrom((*((struct_socket *)
 								(*s_objet_argument_1).objet)).socket,
 								tampon_lecture, 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");
+						}
+#						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)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return;
-							}
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
 						}
 
 						(*s_etat_processus).erreur_execution =
@@ -1536,9 +2132,12 @@ instruction_read(struct_processus *s_eta
 					if (longueur_effective < 0)
 					{
 						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
 						scrutation_injection(s_etat_processus);
 					}
 
+					// Une donnée a été reçue.
+
 					if (((*s_etat_processus).var_volatile_requete_arret == -1)
 							|| (longueur_effective >= 0))
 					{
@@ -1546,10 +2145,13 @@ 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)
+					if (errno == EINTR)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -1747,6 +2349,459 @@ instruction_read(struct_processus *s_eta
 				longueur_adresse = 0;
 				recvfrom((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						longueur_effective, MSG_DONTWAIT,
+						NULL, &longueur_adresse);
+
+				(*s_objet_adresse).objet = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET)
+			{
+				longueur_adresse = sizeof(adresse_ipv4);
+				recvfrom((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						longueur_effective, MSG_DONTWAIT,
+						(struct sockaddr *) &adresse_ipv4, &longueur_adresse);
+
+				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
+				longueur_adresse = sizeof(adresse_ipv6);
+				recvfrom((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						longueur_effective, MSG_DONTWAIT,
+						(struct sockaddr *) &adresse_ipv6, &longueur_adresse);
+
+				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,
+						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')
+		{ // UNFORMATTED
+		}
+		else
+		{ // FLOW
+			longueur_questure = 256;
+
+			do
+			{
+				if ((tampon_lecture = malloc((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;
+				}
+
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				for(;;)
+				{
+					if ((*((struct_socket *) (*s_objet_argument_1).objet))
+							.domaine == PF_UNIX)
+					{
+						longueur_adresse = sizeof(adresse_unix);
+						longueur_effective = recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, longueur_questure,
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_unix, &longueur_adresse);
+					}
+					else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+							.domaine == PF_INET)
+					{
+						longueur_adresse = sizeof(adresse_ipv4);
+						longueur_effective = recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture, 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,
+								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");
+						}
+#						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
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_acces_fichier;
+						return;
+					}
+
+					if (longueur_effective < 0)
+					{
+						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
+						scrutation_injection(s_etat_processus);
+					}
+
+					if (((*s_etat_processus).var_volatile_requete_arret == -1)
+							|| (longueur_effective >= 0))
+					{
+						break;
+					}
+				}
+
+#				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;
+				}
+
+				if (longueur_effective == longueur_questure)
+				{
+					free(tampon_lecture);
+					longueur_questure *= 2;
+				}
+			} while(longueur_effective == longueur_questure);
+
+			longueur_enregistrement = 1;
+
+			for(i = 0; i < longueur_effective; i++)
+			{
+				if (isprint(tampon_lecture[i]) != 0)
+				{
+					longueur_enregistrement += 4;
+				}
+				else
+				{
+					longueur_enregistrement++;
+				}
+			}
+
+			/*
+			 * Création de la liste de sortie
+			 */
+
+			if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*s_objet_type).objet = malloc(longueur_enregistrement *
+					sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			ptr = (*s_objet_type).objet;
+
+			for(i = 0; i < longueur_effective; i++)
+			{
+				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)
+			{
+				(*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 que les domaines sont
+			 * 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))
+			{
+				// 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,
 						NULL, &longueur_adresse);
 
@@ -1834,6 +2889,7 @@ 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,
@@ -1900,6 +2956,18 @@ 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
 			{
@@ -1918,10 +2986,6 @@ instruction_read(struct_processus *s_eta
 				return;
 			}
 		}
-		else
-		{
-			/* FLOW ou UNFORMATTED */
-		}
 	}
 	else
 	{