--- rpl/src/instructions_w1.c	2010/03/07 17:03:29	1.6
+++ rpl/src/instructions_w1.c	2010/07/14 14:19:39	1.19
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.12
+  RPL/2 (R) version 4.0.18
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -262,16 +262,28 @@ instruction_wait(struct_processus *s_eta
 
 		do
 		{
+#			ifndef SEMAPHORES_NOMMES
 			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
+#			else
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+#			endif
 
 			code_retour = nanosleep(&temporisation, &temporisation);
 			erreur = errno;
 
+#			ifndef SEMAPHORES_NOMMES
 			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#			else
+			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#			endif
 			{
 				if (errno != EINTR)
 				{
@@ -379,6 +391,13 @@ instruction_write(struct_processus *s_et
 	int									adresse[16];
 	int									port;
 
+	integer8							clef;
+	integer8							compteur;
+	integer8							id;
+	integer8							ordre;
+
+	logical1							mise_a_jour;
+
 	long								longueur_effective;
 	long								recursivite;
 
@@ -388,6 +407,11 @@ instruction_write(struct_processus *s_et
 
 	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;
@@ -405,6 +429,7 @@ instruction_write(struct_processus *s_et
 
 	unsigned char						*chaine;
 	unsigned char						*chaine_utf8;
+	unsigned char						*clef_utf8;
 	unsigned char						*commande;
 
 	unsigned long						i;
@@ -428,7 +453,7 @@ instruction_write(struct_processus *s_et
 		printf("    1: %s, %s\n\n", d_FCH, d_SCK);
 
 		printf("    3: %s\n", d_LST);
-		printf("    2: %s, %s\n", d_INT, d_CHN);
+		printf("    2: %s\n", d_INT);
 		printf("    1: %s\n", d_FCH);
 		return;
 	}
@@ -449,16 +474,16 @@ instruction_write(struct_processus *s_et
 		if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
 		{
 			if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
-					.donnee).objet)).acces == 'S')
+					.donnee).objet)).acces == 'D')
 			{
-				if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+				if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
 				{
 					return;
 				}
 			}
 			else
 			{
-				if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+				if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
 				{
 					return;
 				}
@@ -597,7 +622,8 @@ instruction_write(struct_processus *s_et
 
 				free(chaine);
 
-				if (fprintf((*descripteur).descripteur_c, "%s\n", chaine) < 0)
+				if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8)
+						< 0)
 				{
 					free(chaine_utf8);
 
@@ -640,64 +666,420 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				if ((*s_objet_argument_3).objet == NULL)
+				// 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)
 				{
-					// Effacement d'un enregistrement
+					liberation(s_etat_processus, s_objet_argument_3);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
 
-					if (alsprintf(&commande, "delete from data where "
-							"id = %lld", (*((integer8 *)
-							(*s_objet_argument_2).objet))) < 0)
-					{
-						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;
+				}
 
-						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 // Fichiers indexés
+			{
+				BUG(((*descripteur).type != 'S'), 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;
+				}
+
+				// 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++;
 				}
-				else
+
+				if ((l_element_courant == NULL) ||
+						(l_element_courant_format == NULL))
 				{
-					// Modification ou création d'un nouvel enregistrement
+					(*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);
 
-					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)
+					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:
 					{
-						liberation(s_etat_processus, s_objet_argument_3);
-						liberation(s_etat_processus, s_objet_argument_2);
-						liberation(s_etat_processus, s_objet_argument_1);
+						// Une clef existe.
 
-						return;
+						mise_a_jour = d_vrai;
+						break;
 					}
 
-					if ((chaine_utf8 = transliteration(s_etat_processus,
-							chaine, d_locale, "UTF-8")) == NULL)
+					case SQLITE_DONE:
 					{
-						free(chaine);
+						// Aucune clef n'existe.
 
-						liberation(s_etat_processus, s_objet_argument_3);
-						liberation(s_etat_processus, s_objet_argument_2);
-						liberation(s_etat_processus, s_objet_argument_1);
+						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;
 					}
+				}
 
-					free(chaine);
+				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 (alsprintf(&commande, "insert or replace into data "
-							"(id, data) values (%lld, '%s')", (*((integer8 *)
-							(*s_objet_argument_2).objet)), chaine_utf8) < 0)
+				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)
 					{
-						free(chaine_utf8);
-						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_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;
 					}
 
-					free(chaine_utf8);
+					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,
@@ -720,12 +1102,170 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				liberation(s_etat_processus, s_objet_argument_3);
 				free(commande);
-			}
-			else
-			{
-				/* Fichiers indexés : panique totale ! */
+
+				// 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
@@ -836,8 +1376,11 @@ instruction_write(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
 				{
 					if (sigaction(SIGPIPE, &registre, NULL) != 0)
 					{
@@ -860,7 +1403,11 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -880,7 +1427,11 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
+#				ifndef SEMAPHORES_NOMMES
 				while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#				else
+				while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#				endif
 				{
 					if (errno != EINTR)
 					{
@@ -932,19 +1483,32 @@ instruction_write(struct_processus *s_et
 							108);
 					adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;
 
+#					ifndef SEMAPHORES_NOMMES
 					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
+#					else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+#					endif
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
 							strlen(chaine), 0, (struct sockaddr *)
 							&adresse_unix, sizeof(adresse_unix)) < 0)
 					{
+#						ifndef SEMAPHORES_NOMMES
 						while(sem_wait(&((*s_etat_processus)
 								.semaphore_fork)) == -1)
+#						else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) == -1)
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -959,7 +1523,11 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -986,20 +1554,33 @@ instruction_write(struct_processus *s_et
 						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)
 						{
 							(*s_etat_processus).erreur_systeme = d_es_processus;
 							return;
 						}
+#						else
+						if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
+						{
+							(*s_etat_processus).erreur_systeme = d_es_processus;
+							return;
+						}
+#						endif
 
 						if (sendto((*((struct_socket *)
 								(*s_objet_argument_1).objet)).socket, chaine,
 								strlen(chaine), 0, (struct sockaddr *)
 								&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
 						{
+#							ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) == -1)
+#							else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) == -1)
+#							endif
 							{
 								if (errno != EINTR)
 								{
@@ -1014,8 +1595,13 @@ instruction_write(struct_processus *s_et
 							return;
 						}
 
+#						ifndef SEMAPHORES_NOMMES
 						while(sem_wait(&((*s_etat_processus)
 								.semaphore_fork)) == -1)
+#						else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) == -1)
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -1056,20 +1642,33 @@ instruction_write(struct_processus *s_et
 								adresse_ipv6.sin6_addr.s6_addr[i] =
 								adresse[i], i++);
 
+#						ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus)
 								.semaphore_fork)) != 0)
 						{
 							(*s_etat_processus).erreur_systeme = d_es_processus;
 							return;
 						}
+#						else
+						if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
+						{
+							(*s_etat_processus).erreur_systeme = d_es_processus;
+							return;
+						}
+#						endif
 
 						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)) == -1)
+#							else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) == -1)
+#							endif
 							{
 								if (errno != EINTR)
 								{
@@ -1084,8 +1683,13 @@ instruction_write(struct_processus *s_et
 							return;
 						}
 
+#						ifndef SEMAPHORES_NOMMES
 						while(sem_wait(&((*s_etat_processus)
 								.semaphore_fork)) == -1)
+#						else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) == -1)
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -1291,13 +1895,25 @@ instruction_wflock(struct_processus *s_e
 				return;
 			}
 
+#			ifndef SEMAPHORES_NOMMES
 			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
+#			else
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+#			endif
 
+#			ifndef SEMAPHORES_NOMMES
 			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#			else
+			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#			endif
 			{
 				if (errno != EINTR)
 				{
@@ -1606,15 +2222,27 @@ instruction_wfproc(struct_processus *s_e
 								registre_instruction_valide;
 					}
 
+#					ifndef SEMAPHORES_NOMMES
 					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
+#					else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+#					endif
 
 					nanosleep(&attente, NULL);
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -1865,15 +2493,27 @@ instruction_wfdata(struct_processus *s_e
 						return;
 					}
 
+#					ifndef SEMAPHORES_NOMMES
 					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
+#					else
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+#					endif
 
 					nanosleep(&attente, NULL);
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2057,11 +2697,19 @@ instruction_wfsock(struct_processus *s_e
 			{
 				drapeau = d_vrai;
 
+#				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
+#				else
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+#				endif
 
 				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
 						accept((*((struct_socket *) (*s_objet_argument).objet))
@@ -2070,7 +2718,11 @@ instruction_wfsock(struct_processus *s_e
 				{
 					erreur = errno;
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2102,7 +2754,11 @@ instruction_wfsock(struct_processus *s_e
 				}
 				else
 				{
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2139,11 +2795,19 @@ instruction_wfsock(struct_processus *s_e
 			{
 				drapeau = d_vrai;
 
+#				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
+#				else
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+#				endif
 
 				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
 						accept((*((struct_socket *) (*s_objet_argument).objet))
@@ -2152,7 +2816,11 @@ instruction_wfsock(struct_processus *s_e
 				{
 					erreur = errno;
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2184,7 +2852,11 @@ instruction_wfsock(struct_processus *s_e
 				}
 				else
 				{
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2229,11 +2901,19 @@ instruction_wfsock(struct_processus *s_e
 			{
 				drapeau = d_vrai;
 
+#				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
+#				else
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+#				endif
 
 				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
 						accept((*((struct_socket *) (*s_objet_argument).objet))
@@ -2241,7 +2921,11 @@ instruction_wfsock(struct_processus *s_e
 				{
 					erreur = errno;
 
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2273,7 +2957,11 @@ instruction_wfsock(struct_processus *s_e
 				}
 				else
 				{
+#					ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#					endif
 					{
 						if (errno != EINTR)
 						{
@@ -2559,15 +3247,27 @@ instruction_wfpoke(struct_processus *s_e
 
 	do
 	{
+#		ifndef SEMAPHORES_NOMMES
 		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
+#		else
+		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+#		endif
 
 		nanosleep(&attente, NULL);
 
+#		ifndef SEMAPHORES_NOMMES
 		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#		else
+		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#		endif
 		{
 			if (errno != EINTR)
 			{
@@ -2709,16 +3409,28 @@ instruction_wfack(struct_processus *s_et
 			return;
 		}
 
+#		ifndef SEMAPHORES_NOMMES
 		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
+#		else
+		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+#		endif
 
 		nanosleep(&attente, NULL);
 		INCR_GRANULARITE(attente.tv_nsec);
 
+#		ifndef SEMAPHORES_NOMMES
 		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#		else
+		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+#		endif
 		{
 			if (errno != EINTR)
 			{