--- rpl/src/instructions_w1.c	2010/03/04 10:17:54	1.4
+++ rpl/src/instructions_w1.c	2011/12/06 13:27:14	1.56
@@ -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.5
+  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"
 
 
 /*
@@ -124,7 +124,7 @@ instruction_while(struct_processus *s_et
 void
 instruction_warranty(struct_processus *s_etat_processus)
 {
-#	include					"garanties.conv.h"
+#	include					"garanties-conv.h"
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -226,8 +226,7 @@ instruction_wait(struct_processus *s_eta
 		return;
 	}
 	
-	if (((*s_objet).type == INT) ||
-			((*s_objet).type == REL))
+	if (((*s_objet).type == INT) || ((*s_objet).type == REL))
 	{
 		if ((*s_objet).type == INT)
 		{
@@ -262,7 +261,11 @@ instruction_wait(struct_processus *s_eta
 
 		do
 		{
-			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;
@@ -271,7 +274,11 @@ instruction_wait(struct_processus *s_eta
 			code_retour = nanosleep(&temporisation, &temporisation);
 			erreur = errno;
 
-			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)
 				{
@@ -374,24 +381,43 @@ instruction_wireframe(struct_processus *
 void
 instruction_write(struct_processus *s_etat_processus)
 {
-	file								*descripteur;
+	const char							*queue;
 
 	int									adresse[16];
 	int									port;
 
+	integer8							clef;
+	integer8							compteur;
+	integer8							id;
+	integer8							ordre;
+
+	logical1							mise_a_jour;
+
 	long								longueur_effective;
 	long								recursivite;
 
+	sqlite3_stmt						*ppStmt;
+
 	ssize_t								ios;
 
-	struct_objet						*s_objet_argument_2;
+	struct_descripteur_fichier			*descripteur;
+
+	struct_liste_chainee				*l_element_courant;
+	struct_liste_chainee				*l_element_courant_format;
+
+	struct_objet						*s_format;
+	struct_objet						*s_element;
 	struct_objet						*s_objet_argument_1;
+	struct_objet						*s_objet_argument_2;
+	struct_objet						*s_objet_argument_3;
 
 	struct sigaction					action;
 	struct sigaction					registre;
 
 	struct sockaddr_in					adresse_ipv4;
+#	ifdef IPV6
 	struct sockaddr_in6					adresse_ipv6;
+#	endif
 	struct sockaddr_un					adresse_unix;
 
 	struct flock						lock;
@@ -399,6 +425,9 @@ instruction_write(struct_processus *s_et
 	uint32_t							calcul_adresse;
 
 	unsigned char						*chaine;
+	unsigned char						*chaine_utf8;
+	unsigned char						*clef_utf8;
+	unsigned char						*commande;
 
 	unsigned long						i;
 
@@ -418,8 +447,11 @@ instruction_write(struct_processus *s_et
 		}
 
 		printf("    2: %s\n", d_LST);
-		printf("    1: %s, %s\n", d_FCH, d_SCK);
+		printf("    1: %s, %s\n\n", d_FCH, d_SCK);
 
+		printf("    3: %s\n", d_LST);
+		printf("    2: %s\n", d_INT);
+		printf("    1: %s\n", d_FCH);
 		return;
 	}
 	else if ((*s_etat_processus).test_instruction == 'Y')
@@ -430,10 +462,37 @@ instruction_write(struct_processus *s_et
 
 	if (test_cfsf(s_etat_processus, 31) == d_vrai)
 	{
-		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+		if ((*s_etat_processus).l_base_pile == NULL)
 		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 			return;
 		}
+
+		if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
+		{
+			if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
+					.donnee).objet)).acces == 'D')
+			{
+				if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+				{
+					return;
+				}
+			}
+			else
+			{
+				if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+				{
+					return;
+				}
+			}
+		}
+		else
+		{
+			if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+			{
+				return;
+			}
+		}
 	}
 
 	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
@@ -452,9 +511,14 @@ instruction_write(struct_processus *s_et
 		return;
 	}
 	
-	if (((*s_objet_argument_2).type == LST) &&
-			((*s_objet_argument_1).type == FCH))
+	if ((*s_objet_argument_1).type == FCH)
 	{
+		if ((descripteur = descripteur_fichier(s_etat_processus,
+				(struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
+		{
+			return;
+		}
+
 		/*
 		 * Vérification des verrous
 		 */
@@ -466,13 +530,8 @@ instruction_write(struct_processus *s_et
 		lock.l_pid = getpid();
 		recursivite = 0;
 
-		if ((descripteur = descripteur_fichier(s_etat_processus,
-				(struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
-		{
-			return;
-		}
-
-		if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
+		if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
+				== -1)
 		{
 			liberation(s_etat_processus, s_objet_argument_2);
 			liberation(s_etat_processus, s_objet_argument_1);
@@ -511,21 +570,34 @@ instruction_write(struct_processus *s_et
 			 * Fichiers formatés
 			 */
 
-			if ((chaine = formateur_fichier(s_etat_processus,
-					s_objet_argument_2, (*((struct_fichier *)
-					(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
-					&longueur_effective, &recursivite)) == NULL)
-			{
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_1);
-
-				return;
-			}
-
 			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 					== 'S')
 			{
-				if (fseek(descripteur, (long) 0, SEEK_END) != 0)
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_objet_argument_2, (*((struct_fichier *)
+						(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
+						&longueur_effective, &recursivite)) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
+
+				if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
+						!= 0)
 				{
 					liberation(s_etat_processus, s_objet_argument_2);
 					liberation(s_etat_processus, s_objet_argument_1);
@@ -534,22 +606,664 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				if (fprintf(descripteur, "%s\n", chaine) < 0)
+				if ((chaine_utf8 = transliteration(s_etat_processus,
+						chaine, d_locale, "UTF-8")) == NULL)
 				{
+					free(chaine);
+
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				free(chaine);
+
+				if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8)
+						< 0)
+				{
+					free(chaine_utf8);
+
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
+
+				free(chaine_utf8);
 			}
 			else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 					== 'D')
 			{
+				BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
+
+				if ((*s_objet_argument_2).type != INT)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_argument_3) == d_erreur)
+				{
+					(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+					return;
+				}
+
+				if ((*s_objet_argument_3).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_3);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				// Modification ou création d'un nouvel enregistrement
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_objet_argument_3, (*((struct_fichier *)
+						(*s_objet_argument_1).objet)).format, 0, 0, ' ',
+						'F', &longueur_effective, &recursivite)) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_3);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				if ((chaine_utf8 = transliteration(s_etat_processus,
+						chaine, d_locale, "UTF-8")) == NULL)
+				{
+					free(chaine);
+
+					liberation(s_etat_processus, s_objet_argument_3);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				free(chaine);
+
+				if (alsprintf(&commande, "insert or replace into data "
+						"(id, data) values (%lld, '%s')", (*((integer8 *)
+						(*s_objet_argument_2).objet)), chaine_utf8) < 0)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				free(chaine_utf8);
+
+				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_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;
+				}
+
+				liberation(s_etat_processus, s_objet_argument_3);
+				free(commande);
 			}
-			else
+			else // Fichiers indexés
 			{
-				/* Fichiers indexés : panique totale ! */
-			}
+				BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
 
-			free(chaine);
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*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;
+				}
+
+				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);
+
+				l_element_courant = (struct_liste_chainee *)
+						(*s_objet_argument_2).objet;
+				l_element_courant_format = (struct_liste_chainee *)
+						(*(*((struct_fichier *) (*s_objet_argument_1).objet))
+						.format).objet;
+				compteur = 1;
+
+				while((l_element_courant != NULL) &&
+						(l_element_courant_format != NULL))
+				{
+					if (compteur == clef)
+					{
+						break;
+					}
+
+					l_element_courant = (*l_element_courant).suivant;
+					l_element_courant_format = (*l_element_courant_format)
+							.suivant;
+					compteur++;
+				}
+
+				if ((l_element_courant == NULL) ||
+						(l_element_courant_format == NULL))
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_clef_inexistante;
+						
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				if ((s_element = allocation(s_etat_processus, LST)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*s_element).objet = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_liste_chainee *) (*s_element).objet)).suivant = NULL;
+
+				if (((*((struct_liste_chainee *) (*s_element).objet))
+						.donnee = copie_objet(s_etat_processus,
+						(*l_element_courant).donnee, 'N')) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if ((s_format = allocation(s_etat_processus, LST)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*s_format).objet = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_liste_chainee *) (*s_format).objet)).suivant = NULL;
+
+				if (((*((struct_liste_chainee *) (*s_format).objet))
+						.donnee = copie_objet(s_etat_processus,
+						(*l_element_courant_format).donnee, 'N')) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_element, s_format, 0, 0, ' ',
+						'F', &longueur_effective, &recursivite)) == NULL)
+				{
+					liberation(s_etat_processus, s_element);
+					liberation(s_etat_processus, s_format);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				liberation(s_etat_processus, s_element);
+				liberation(s_etat_processus, s_format);
+
+				if ((clef_utf8 = transliteration(s_etat_processus,
+						chaine, d_locale, "UTF-8")) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
+				free(chaine);
+
+				// 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:
+					{
+						// Une clef existe.
+
+						mise_a_jour = d_vrai;
+						break;
+					}
+
+					case SQLITE_DONE:
+					{
+						// Aucune clef n'existe.
+
+						mise_a_jour = d_faux;
+
+						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+
+						free(commande);
+
+						if (alsprintf(&commande, "insert into key "
+								"(key) values ('%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;
+						}
+
+						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 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;
+						}
+
+						if (sqlite3_step(ppStmt) != SQLITE_ROW)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+
+						break;
+					}
+
+					default:
+					{
+						(*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;
+				}
+
+				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);
+
+				// Modification de la clef
+
+				if (mise_a_jour == d_vrai)
+				{
+					if (alsprintf(&commande, "update key set key = '%s' where "
+							"id = %lld", clef_utf8, 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;
+					}
+
+					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);
+				}
+
+				// Effacement de l'enregistrement existant
+
+				if (alsprintf(&commande, "delete from data where "
+						"key_id = %lld", 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;
+				}
+
+				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);
+
+				// Modification ou création d'un nouvel enregistrement
+
+				l_element_courant = (struct_liste_chainee *)
+						(*s_objet_argument_2).objet;
+				l_element_courant_format = (struct_liste_chainee *)
+						(*(*((struct_fichier *) (*s_objet_argument_1).objet))
+						.format).objet;
+				compteur = 1;
+				ordre = 1;
+
+				while((l_element_courant != NULL) &&
+						(l_element_courant_format != NULL))
+				{
+					if (compteur == clef)
+					{
+						l_element_courant = (*l_element_courant).suivant;
+						l_element_courant_format = (*l_element_courant_format)
+								.suivant;
+						compteur++;
+						continue;
+					}
+
+					if ((s_element = allocation(s_etat_processus, LST)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (((*s_element).objet =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					(*((struct_liste_chainee *) (*s_element).objet)).suivant
+							= NULL;
+
+					if ((s_format = allocation(s_etat_processus, LST)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (((*s_format).objet =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					(*((struct_liste_chainee *) (*s_format).objet)).suivant
+							= NULL;
+
+					if (((*((struct_liste_chainee *) (*s_element).objet))
+							.donnee = copie_objet(s_etat_processus,
+							(*l_element_courant).donnee, 'N')) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (((*((struct_liste_chainee *) (*s_format).objet))
+							.donnee = copie_objet(s_etat_processus,
+							(*l_element_courant_format).donnee, 'N')) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if ((chaine = formateur_fichier(s_etat_processus,
+							s_element, s_format, 0, 0, ' ',
+							'F', &longueur_effective, &recursivite)) == NULL)
+					{
+						free(clef_utf8);
+
+						liberation(s_etat_processus, s_element);
+						liberation(s_etat_processus, s_format);
+						liberation(s_etat_processus, s_objet_argument_2);
+						liberation(s_etat_processus, s_objet_argument_1);
+
+						return;
+					}
+
+					if ((chaine_utf8 = transliteration(s_etat_processus,
+							chaine, d_locale, "UTF-8")) == NULL)
+					{
+						free(clef_utf8);
+						free(chaine);
+
+						liberation(s_etat_processus, s_objet_argument_2);
+						liberation(s_etat_processus, s_objet_argument_1);
+
+						return;
+					}
+
+					free(chaine);
+
+					if (alsprintf(&commande, "insert into data "
+							"(data, key_id, sequence) values "
+							"('%s', %lld, %lld)", chaine_utf8, id, ordre) < 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_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);
+					free(chaine_utf8);
+
+					liberation(s_etat_processus, s_element);
+					liberation(s_etat_processus, s_format);
+
+					l_element_courant = (*l_element_courant).suivant;
+					l_element_courant_format = (*l_element_courant_format)
+							.suivant;
+
+					compteur++;
+					ordre++;
+				}
+
+				free(clef_utf8);
+
+				if ((l_element_courant != NULL) ||
+						(l_element_courant_format != NULL))
+				{
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_format_fichier;
+					return;
+				}
+			}
 		}
 		else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
 				== 'Y')
@@ -572,7 +1286,10 @@ instruction_write(struct_processus *s_et
 			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 					== 'S')
 			{
-				if (fseek(descripteur, (long) 0, SEEK_END) != 0)
+				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
+
+				if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
+						!= 0)
 				{
 					liberation(s_etat_processus, s_objet_argument_2);
 					liberation(s_etat_processus, s_objet_argument_1);
@@ -582,7 +1299,8 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
-						descripteur) != (size_t) longueur_effective)
+						(*descripteur).descripteur_c) !=
+						(size_t) longueur_effective)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
@@ -604,6 +1322,72 @@ instruction_write(struct_processus *s_et
 			/*
 			 * Fichiers de type FLOW
 			 */
+
+			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
+					== 'S')
+			{
+				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
+
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+						.donnee == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+						.donnee)).type != CHN)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
+						(*((*((struct_liste_chainee *) (*s_objet_argument_2)
+						.objet)).donnee)).objet, &longueur_effective)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
+						(*descripteur).descripteur_c) !=
+						(size_t) longueur_effective)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+					return;
+				}
+
+				free(chaine);
+			}
+			else
+			{
+				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_fichier;
+				return;
+			}
 		}
 	}
 	else if (((*s_objet_argument_2).type == LST) &&
@@ -639,47 +1423,190 @@ instruction_write(struct_processus *s_et
 
 				return;
 			}
+		}
+		else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
+				== 'Y')
+		{
+			/*
+			 * Sockets non formatées
+			 */
+
+			chaine = NULL;
+		}
+		else
+		{
+			/*
+			 * 	Sockets de type FLOW
+			 */
+
+			if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+					.donnee)).type != CHN)
+			{
+				liberation(s_etat_processus, s_objet_argument_2);
+				liberation(s_etat_processus, s_objet_argument_1);
+
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_type_argument;
+				return;
+			}
 
-			if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
-					"STREAM") == 0) || (strcmp((*((struct_socket *)
-					(*s_objet_argument_1).objet)).type,
-					"SEQUENTIAL DATAGRAM") == 0))
-			{ // Sockets connectées
+			if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
+					(*((*((struct_liste_chainee *) (*s_objet_argument_2)
+					.objet)).donnee)).objet, &longueur_effective)) == NULL)
+			{
+				liberation(s_etat_processus, s_objet_argument_2);
+				liberation(s_etat_processus, s_objet_argument_1);
 
-				action.sa_handler = SIG_IGN;
-				action.sa_flags = SA_ONSTACK;
+				return;
+			}
+		}
+
+		if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
+				"STREAM") == 0) || (strcmp((*((struct_socket *)
+				(*s_objet_argument_1).objet)).type,
+				"SEQUENTIAL DATAGRAM") == 0))
+		{ // Sockets connectées
+
+			action.sa_handler = SIG_IGN;
+			action.sa_flags = SA_ONSTACK;
+
+			if (sigaction(SIGPIPE, &action, &registre) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_signal;
+				return;
+			}
 
-				if (sigaction(SIGPIPE, &action, &registre) != 0)
+#			ifndef SEMAPHORES_NOMMES
+				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#			else
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#			endif
+			{
+				if (sigaction(SIGPIPE, &registre, NULL) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return;
 				}
 
-				if (sem_post(&((*s_etat_processus).semaphore_fork))
-						!= 0)
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
+			if (send((*((struct_socket *) (*s_objet_argument_1).objet))
+					.socket, chaine, longueur_effective, 0) < 0)
+			{
+				ios = errno;
+
+				if (sigaction(SIGPIPE, &registre, NULL) != 0)
 				{
-					if (sigaction(SIGPIPE, &registre, NULL) != 0)
+					(*s_etat_processus).erreur_systeme = d_es_signal;
+					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_signal;
+						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
+				}
 
-					(*s_etat_processus).erreur_systeme = d_es_processus;
+				if ((ios == EPIPE) || (ios == ECONNRESET))
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
 					return;
 				}
 
-				if (send((*((struct_socket *) (*s_objet_argument_1).objet))
-						.socket, chaine, strlen(chaine), 0) < 0)
-				{
-					ios = errno;
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				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)
+				{
 					if (sigaction(SIGPIPE, &registre, NULL) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_signal;
 						return;
 					}
 
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+			}
+
+			if (sigaction(SIGPIPE, &registre, NULL) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_signal;
+				return;
+			}
+		}
+		else
+		{ // Sockets non connectées
+
+			/*
+			 * Vérification de l'adresse distante
+			 */
+
+			if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
+					.adresse_distante, "") == 0)
+			{
+				liberation(s_etat_processus, s_objet_argument_1);
+				liberation(s_etat_processus, s_objet_argument_2);
+
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_acces_fichier;
+				return;
+			}
+
+			/*
+			 * Création de l'adresse logique
+			 */
+
+			if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_UNIX)
+			{
+				adresse_unix.sun_family = AF_UNIX;
+				strncpy(adresse_unix.sun_path, (*((struct_socket *)
+						(*s_objet_argument_1).objet)).adresse_distante,
+						UNIX_PATH_MAX);
+				adresse_unix.sun_path[UNIX_PATH_MAX - 1] =
+						d_code_fin_chaine;
+
+#				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 (sendto((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, chaine,
+						longueur_effective, 0, (struct sockaddr *)
+						&adresse_unix, sizeof(adresse_unix)) < 0)
+				{
+					ios = errno;
+
+#					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)
 						{
@@ -688,70 +1615,55 @@ instruction_write(struct_processus *s_et
 						}
 					}
 
-					if (ios == EPIPE)
+					if ((ios == EPIPE) || (ios == ECONNRESET))
 					{
 						(*s_etat_processus).erreur_execution =
 								d_ex_erreur_acces_fichier;
 						return;
 					}
 
+
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				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 (sigaction(SIGPIPE, &registre, NULL) != 0)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_signal;
-							return;
-						}
-
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
 				}
-
-				if (sigaction(SIGPIPE, &registre, NULL) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_signal;
-					return;
-				}
 			}
-			else
-			{ // Sockets non connectées
-
-				/*
-				 * Vérification de l'adresse distante
-				 */
-
-				if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
-						.adresse_distante, "") == 0)
-				{
-					liberation(s_etat_processus, s_objet_argument_1);
-					liberation(s_etat_processus, s_objet_argument_2);
-
-					(*s_etat_processus).erreur_execution =
-							d_ex_erreur_acces_fichier;
-					return;
-				}
-
-				/*
-				 * Création de l'adresse logique
-				 */
-
-				if ((*((struct_socket *) (*s_objet_argument_1).objet))
-						.domaine == PF_UNIX)
-				{
-					adresse_unix.sun_family = AF_UNIX;
-					strncpy(adresse_unix.sun_path, (*((struct_socket *)
-							(*s_objet_argument_1).objet)).adresse_distante,
-							108);
-					adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;
-
-					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET)
+			{
+				if (sscanf((*((struct_socket *)
+						(*s_objet_argument_1).objet))
+						.adresse_distante, "%d.%d.%d.%d(%d)",
+						&(adresse[0]), &(adresse[1]), &(adresse[2]),
+						&(adresse[3]), &port) == 5)
+				{ // Adresse IPv4
+					calcul_adresse = 0;
+					for(i = 0; i < 4; calcul_adresse =
+							(256 * calcul_adresse) + adresse[i++]);
+
+					memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
+					adresse_ipv4.sin_family = AF_INET;
+					adresse_ipv4.sin_port = htons(port);
+					adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
+
+#					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;
@@ -759,11 +1671,16 @@ instruction_write(struct_processus *s_et
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
-							strlen(chaine), 0, (struct sockaddr *)
-							&adresse_unix, sizeof(adresse_unix)) < 0)
+							longueur_effective, 0, (struct sockaddr *)
+							&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
 					{
-						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)
 							{
@@ -778,7 +1695,12 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
-					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)
 						{
@@ -787,54 +1709,61 @@ instruction_write(struct_processus *s_et
 						}
 					}
 				}
-				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
-						.domaine == PF_INET)
+				else
 				{
-					if (sscanf((*((struct_socket *)
-							(*s_objet_argument_1).objet))
-							.adresse_distante, "%d.%d.%d.%d(%d)",
-							&(adresse[0]), &(adresse[1]), &(adresse[2]),
-							&(adresse[3]), &port) == 5)
-					{ // Adresse IPv4
-						calcul_adresse = 0;
-						for(i = 0; i < 4; calcul_adresse =
-								(256 * calcul_adresse) + adresse[i++]);
-
-						memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
-						adresse_ipv4.sin_family = AF_INET;
-						adresse_ipv4.sin_port = htons(port);
-						adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
 
-						if (sem_post(&((*s_etat_processus)
-								.semaphore_fork)) != 0)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_parametre_fichier;
+					return;
+				}
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET6)
+			{
+				if (sscanf((*((struct_socket *) (*s_objet_argument_1)
+						.objet)).adresse_distante, "%X:%X:%X:%X:%X:"
+						"%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
+						&(adresse[0]), &(adresse[1]), &(adresse[2]),
+						&(adresse[3]), &(adresse[4]), &(adresse[5]),
+						&(adresse[6]), &(adresse[7]), &(adresse[8]),
+						&(adresse[9]), &(adresse[10]), &(adresse[11]),
+						&(adresse[12]), &(adresse[13]), &(adresse[14]),
+						&(adresse[15]), &port)== 17)
+				{ // Adresse IPv6
+#					ifdef IPV6
+					memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
+					adresse_ipv6.sin6_family = AF_INET6;
+					adresse_ipv6.sin6_port = htons((uint16_t) port);
+
+					for(i = 0; i < 16;
+							adresse_ipv6.sin6_addr.s6_addr[i] =
+							adresse[i], i++);
+
+#					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 (sendto((*((struct_socket *)
-								(*s_objet_argument_1).objet)).socket, chaine,
-								strlen(chaine), 0, (struct sockaddr *)
-								&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
-						{
+					if (sendto((*((struct_socket *)
+							(*s_objet_argument_1).objet)).socket, chaine,
+							longueur_effective, 0, (struct sockaddr *)
+							&adresse_ipv6, sizeof(adresse_ipv6)) < 0)
+					{
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
-									.semaphore_fork)) == -1)
-							{
-								if (errno != EINTR)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-									return;
-								}
-							}
-
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
-						}
-
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -843,88 +1772,40 @@ instruction_write(struct_processus *s_et
 								return;
 							}
 						}
-					}
-					else
-					{
-						liberation(s_etat_processus, s_objet_argument_1);
-						liberation(s_etat_processus, s_objet_argument_2);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_parametre_fichier;
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
 						return;
 					}
-				}
-				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
-						.domaine == PF_INET6)
-				{
-					if (sscanf((*((struct_socket *) (*s_objet_argument_1)
-							.objet)).adresse_distante, "%X:%X:%X:%X:%X:"
-							"%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
-							&(adresse[0]), &(adresse[1]), &(adresse[2]),
-							&(adresse[3]), &(adresse[4]), &(adresse[5]),
-							&(adresse[6]), &(adresse[7]), &(adresse[8]),
-							&(adresse[9]), &(adresse[10]), &(adresse[11]),
-							&(adresse[12]), &(adresse[13]), &(adresse[14]),
-							&(adresse[15]), &port)== 17)
-					{ // Adresse IPv6
-						memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
-						adresse_ipv6.sin6_family = AF_INET6;
-						adresse_ipv6.sin6_port = htons((uint16_t) port);
-
-						for(i = 0; i < 16;
-								adresse_ipv6.sin6_addr.s6_addr[i] =
-								adresse[i], i++);
 
-						if (sem_post(&((*s_etat_processus)
-								.semaphore_fork)) != 0)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
-
-						if (sendto((*((struct_socket *)
-								(*s_objet_argument_1).objet)).socket, chaine,
-								strlen(chaine), 0, (struct sockaddr *)
-								&adresse_ipv6, sizeof(adresse_ipv6)) < 0)
+#					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)
 						{
-							while(sem_wait(&((*s_etat_processus)
-									.semaphore_fork)) == -1)
-							{
-								if (errno != EINTR)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-									return;
-								}
-							}
-
 							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
+									d_es_processus;
 							return;
 						}
-
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
-						{
-							if (errno != EINTR)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return;
-							}
-						}
+					}
+#					else
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Attention : Support du protocole"
+								" IPv6 indisponible\n");
 					}
 					else
 					{
-						liberation(s_etat_processus, s_objet_argument_1);
-						liberation(s_etat_processus, s_objet_argument_2);
-
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_parametre_fichier;
-						return;
+						printf("+++Warning : IPv6 support "
+								"unavailable\n");
 					}
+#					endif
 				}
-				else 
+				else
 				{
 					liberation(s_etat_processus, s_objet_argument_1);
 					liberation(s_etat_processus, s_objet_argument_2);
@@ -934,22 +1815,18 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 			}
+			else 
+			{
+				liberation(s_etat_processus, s_objet_argument_1);
+				liberation(s_etat_processus, s_objet_argument_2);
 
-			free(chaine);
-		}
-		else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
-				== 'Y')
-		{
-			/*
-			 * Sockets non formatées
-			 */
-		}
-		else
-		{
-			/*
-			 * 	Sockets de type FLOW
-			 */
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_parametre_fichier;
+				return;
+			}
 		}
+
+		free(chaine);
 	}
 	else
 	{
@@ -982,14 +1859,14 @@ instruction_write(struct_processus *s_et
 void
 instruction_wflock(struct_processus *s_etat_processus)
 {
-	file						*descripteur;
-
 	logical1					drapeau;
 
 	struct flock				lock;
 
 	struct timespec				attente;
 
+	struct_descripteur_fichier	*descripteur;
+
 	struct_objet				*s_objet_argument_1;
 	struct_objet				*s_objet_argument_2;
 
@@ -1100,7 +1977,8 @@ instruction_wflock(struct_processus *s_e
 				return;
 			}
 
-			if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
+			if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
+					== -1)
 			{
 				liberation(s_etat_processus, s_objet_argument_1);
 				liberation(s_etat_processus, s_objet_argument_2);
@@ -1109,13 +1987,21 @@ instruction_wflock(struct_processus *s_e
 				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;
 			}
 
-			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)
 				{
@@ -1338,9 +2224,9 @@ instruction_wfproc(struct_processus *s_e
 				if ((*(*((struct_processus_fils *) (*(*l_element_courant)
 						.donnee).objet)).thread).processus_detache == d_vrai)
 				{
-					if (kill((*(*((struct_processus_fils *)
+					if (envoi_signal_processus((*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread).pid,
-							0) != 0)
+							rpl_signull) != 0)
 					{
 						drapeau_fin = d_vrai;
 					}
@@ -1424,7 +2310,12 @@ instruction_wfproc(struct_processus *s_e
 								registre_instruction_valide;
 					}
 
-					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;
@@ -1432,7 +2323,12 @@ instruction_wfproc(struct_processus *s_e
 
 					nanosleep(&attente, NULL);
 
-					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)
 						{
@@ -1683,7 +2579,12 @@ instruction_wfdata(struct_processus *s_e
 						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;
@@ -1691,7 +2592,12 @@ instruction_wfdata(struct_processus *s_e
 
 					nanosleep(&attente, NULL);
 
-					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)
 						{
@@ -1800,8 +2706,12 @@ instruction_wfsock(struct_processus *s_e
 	struct_objet			*s_objet_argument;
 	struct_objet			*s_objet_resultat;
 
+	struct pollfd			s_poll;
+
 	struct sockaddr_in		adresse_ipv4;
+#	ifdef IPV6
 	struct sockaddr_in6		adresse_ipv6;
+#	endif
 
 	unsigned long			i;
 
@@ -1851,51 +2761,44 @@ instruction_wfsock(struct_processus *s_e
 				"STREAM") != 0) && (strcmp((*((struct_socket *)
 				(*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
 		{
-			liberation(s_etat_processus, s_objet_argument);
-
-			(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
-			return;
-		}
+			// Mode non connecté : l'attente se fait sur un poll()
 
-		if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,
-				'O')) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
-
-		(*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';
-		(*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'P')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)
-		{
-			longueur = sizeof(adresse_ipv4);
+			s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket;
+			s_poll.events = POLLIN;
+			s_poll.revents = 0;
 
 			do
 			{
 				drapeau = d_vrai;
 
+#				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_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, (struct sockaddr *) &adresse_ipv4, &longueur))
-						< 0)
+				if (poll(&s_poll, 1, -1) < 0)
 				{
 					erreur = errno;
 
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-					{
-						if (errno != EINTR)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							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 (erreur != EINTR)
 					{
@@ -1920,251 +2823,425 @@ instruction_wfsock(struct_processus *s_e
 				}
 				else
 				{
-					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;
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
 							return;
 						}
 					}
 				}
 			} while(drapeau == d_faux);
 
-			if (((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = malloc(22 *
-					sizeof(unsigned char))) == NULL)
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument) == d_erreur)
 			{
-				(*s_etat_processus).erreur_systeme =
-						d_es_allocation_memoire;
 				return;
 			}
 
-			sprintf((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante, "%d.%d.%d.%d(%d)",
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
-					ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
-					ntohs(adresse_ipv4.sin_port));
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
 		}
-		else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
-				PF_INET6)
+		else
 		{
-			longueur = sizeof(adresse_ipv6);
+			// Mode connecté
 
-			do
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'O')) == NULL)
 			{
-				drapeau = d_vrai;
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+			(*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
+			(*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
+					= 'N';
 
-				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, (struct sockaddr *) &adresse_ipv6, &longueur))
-						< 0)
+			if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
+					PF_INET)
+			{
+				longueur = sizeof(adresse_ipv4);
+
+				do
 				{
-					erreur = errno;
+					drapeau = d_vrai;
 
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#				ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#				else
+						if (sem_post((*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;
+						return;
 					}
 
-					if (erreur != EINTR)
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket,
+							(struct sockaddr *) &adresse_ipv4, &longueur))
+							< 0)
 					{
-						liberation(s_etat_processus, s_objet_argument);
-						liberation(s_etat_processus, s_objet_resultat);
+						erreur = errno;
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_acces_fichier;
-						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;
+							}
+						}
 
-					scrutation_injection(s_etat_processus);
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
 
-					if ((*s_etat_processus).var_volatile_requete_arret != 0)
-					{
-						drapeau = d_vrai;
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
+
+						scrutation_injection(s_etat_processus);
+
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
 					}
 					else
 					{
-						drapeau = d_faux;
+#					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;
+							}
+						}
 					}
-				}
-				else
+				} while(drapeau == d_faux);
+
+				if (((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = malloc(22 *
+						sizeof(unsigned char))) == NULL)
 				{
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				sprintf((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante, "%d.%d.%d.%d(%d)",
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
+						ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
+						ntohs(adresse_ipv4.sin_port));
+			}
+			else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
+					PF_INET6)
+			{
+#			ifdef IPV6
+				longueur = sizeof(adresse_ipv6);
+
+				do
+				{
+					drapeau = d_vrai;
+
+#				ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#				else
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 					{
-						if (errno != EINTR)
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket,
+							(struct sockaddr *) &adresse_ipv6, &longueur)) < 0)
+					{
+						erreur = errno;
+
+#					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;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
 							return;
 						}
+
+						scrutation_injection(s_etat_processus);
+
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
+					}
+					else
+					{
+#					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;
+							}
+						}
 					}
+				} while(drapeau == d_faux);
+
+				if (((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = malloc(55 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
 				}
-			} while(drapeau == d_faux);
 
-			if (((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = malloc(55 *
-					sizeof(unsigned char))) == NULL)
-			{
-				(*s_etat_processus).erreur_systeme =
-						d_es_allocation_memoire;
-				return;
-			}
+				(*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = d_code_fin_chaine;
 
-			(*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = d_code_fin_chaine;
+				for(i = 0; i < 16; i++)
+				{
+					sprintf((*((struct_socket *) (*s_objet_resultat)
+							.objet)).adresse_distante, (i == 0) ? "%s%X"
+							: "%s:%X", (*((struct_socket *) (*s_objet_resultat)
+							.objet)).adresse_distante,
+							adresse_ipv6.sin6_addr.s6_addr[i]);
+				}
 
-			for(i = 0; i < 16; i++)
-			{
 				sprintf((*((struct_socket *) (*s_objet_resultat)
-						.objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X",
+						.objet)).adresse_distante, "%s(%u)",
 						(*((struct_socket *) (*s_objet_resultat)
 						.objet)).adresse_distante,
-						adresse_ipv6.sin6_addr.s6_addr[i]);
+						ntohs(adresse_ipv6.sin6_port));
+#			else
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#			endif
 			}
-
-			sprintf((*((struct_socket *) (*s_objet_resultat)
-					.objet)).adresse_distante, "%s(%u)",
-					(*((struct_socket *) (*s_objet_resultat)
-					.objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));
-		}
-		else
-		{
-			longueur = 0;
-
-			do
+			else
 			{
-				drapeau = d_vrai;
+				longueur = 0;
 
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+				do
 				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+					drapeau = d_vrai;
 
-				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, NULL, &longueur)) < 0)
-				{
-					erreur = errno;
+#				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;
+					}
 
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket, NULL,
+							&longueur)) < 0)
 					{
-						if (errno != EINTR)
+						erreur = errno;
+
+#					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;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
-					}
 
-					if (erreur != EINTR)
-					{
-						liberation(s_etat_processus, s_objet_argument);
-						liberation(s_etat_processus, s_objet_resultat);
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_acces_fichier;
-						return;
-					}
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
 
-					scrutation_injection(s_etat_processus);
+						scrutation_injection(s_etat_processus);
 
-					if ((*s_etat_processus).var_volatile_requete_arret != 0)
-					{
-						drapeau = d_vrai;
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
 					}
 					else
 					{
-						drapeau = d_faux;
-					}
-				}
-				else
-				{
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-					{
-						if (errno != EINTR)
+#					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;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
 					}
-				}
-			} while(drapeau == d_faux);
-		}
-
-		// Si accept() renvoie une erreur non récupérée, il ne peut s'agir
-		// que de EINTR sachant qu'une requête d'arrêt est en court de
-		// traitement.
+				} while(drapeau == d_faux);
+			}
 
-		if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
-		{
-			l_element_courant = (*s_etat_processus).s_sockets;
+			// Si accept() renvoie une erreur non récupérée, il ne peut s'agir
+			// que de EINTR sachant qu'une requête d'arrêt est en court de
+			// traitement.
 
-			if (l_element_courant == NULL)
+			if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
 			{
-				if (((*s_etat_processus).s_sockets =
-						allocation_maillon(s_etat_processus)) == NULL)
+				l_element_courant = (*s_etat_processus).s_sockets;
+
+				if (l_element_courant == NULL)
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
-					return;
+					if (((*s_etat_processus).s_sockets =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					(*(*s_etat_processus).s_sockets).suivant = NULL;
+					l_element_courant = (*s_etat_processus).s_sockets;
 				}
+				else
+				{
+					/*
+					 * Ajout d'un élément à la fin de la liste chaînée
+					 */
 
-				(*(*s_etat_processus).s_sockets).suivant = NULL;
-				l_element_courant = (*s_etat_processus).s_sockets;
-			}
-			else
-			{
-				/*
-				 * Ajout d'un élément à la fin de la liste chaînée
-				 */
+					while((*l_element_courant).suivant != NULL)
+					{
+						l_element_courant = (*l_element_courant).suivant;
+					}
+
+					if (((*l_element_courant).suivant =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
 
-				while((*l_element_courant).suivant != NULL)
-				{
 					l_element_courant = (*l_element_courant).suivant;
+					(*l_element_courant).suivant = NULL;
 				}
 
-				if (((*l_element_courant).suivant =
-						allocation_maillon(s_etat_processus)) == NULL)
+				if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
+						s_objet_resultat, 'O')) == 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 = copie_objet(s_etat_processus,
-					s_objet_resultat, 'O')) == NULL)
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument) == d_erreur)
 			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
-		}
-
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				s_objet_argument) == d_erreur)
-		{
-			return;
-		}
 
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				s_objet_resultat) == d_erreur)
-		{
-			return;
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
 		}
 	}
 	else
@@ -2377,7 +3454,11 @@ instruction_wfpoke(struct_processus *s_e
 
 	do
 	{
-		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;
@@ -2385,7 +3466,11 @@ instruction_wfpoke(struct_processus *s_e
 
 		nanosleep(&attente, NULL);
 
-		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)
 			{
@@ -2527,7 +3612,11 @@ instruction_wfack(struct_processus *s_et
 			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;
@@ -2536,7 +3625,11 @@ instruction_wfack(struct_processus *s_et
 		nanosleep(&attente, NULL);
 		INCR_GRANULARITE(attente.tv_nsec);
 
-		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)
 			{