--- rpl/src/rpl.c	2011/09/14 14:34:28	1.83
+++ rpl/src/rpl.c	2011/09/14 17:56:00	1.84
@@ -114,19 +114,18 @@ rplinit(int argc, char *argv[], unsigned
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
+	// mutex_liste_thread est dévérouillé par défaut.
+	// mutex_gestionnaires_signaux et mutex_gestionnaires_signaux_atomique
+	// sont verrouillés par défaut.
+
+	pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique);
+
 #	ifndef SEMAPHORES_NOMMES
-	sem_init(&semaphore_liste_threads, 0, 1);
 	sem_init(&semaphore_gestionnaires_signaux, 0, 0);
-	sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
 #	else
-	semaphore_liste_threads = sem_init2(1, sem_liste_threads);
 	semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
-	semaphore_gestionnaires_signaux_atomique = sem_init2(1,
-			sem_gestionnaires_signaux_atomique);
-
-	if ((semaphore_liste_threads == SEM_FAILED) ||
-			(semaphore_gestionnaires_signaux == SEM_FAILED) ||
-			(semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
+	
+	if (semaphore_gestionnaires_signaux == SEM_FAILED)
 	{
 		erreur = d_es_allocation_memoire;
 
@@ -189,7 +188,6 @@ rplinit(int argc, char *argv[], unsigned
 	(*s_etat_processus).erreur_systeme = d_es;
 	(*s_etat_processus).erreur_execution = d_ex;
 	(*s_etat_processus).compteur_violation_d_acces = 0;
-	(*s_etat_processus).tid_courant = pthread_self();
 
 	(*s_etat_processus).rpl_home = rpl_home;
 
@@ -204,24 +202,12 @@ rplinit(int argc, char *argv[], unsigned
 			&attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
-#	else
-	if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==
-			SEM_FAILED)
-	{
-		if ((*s_etat_processus).langue == 'F')
-		{
-			uprintf("+++Système : Mémoire insuffisante\n");
-		}
-		else
-		{
-			uprintf("+++System : Not enough memory\n");
-		}
-
-		return(EXIT_FAILURE);
-	}
-#	endif
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_etat_processus).mutex_fork),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
 
 	pthread_mutexattr_init(&attributs_mutex);
 	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
@@ -334,42 +320,6 @@ rplinit(int argc, char *argv[], unsigned
 		home = "";
 	}
 
-	// Initialisation d'une clef
-
-	if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)
-	{
-		if ((*s_etat_processus).langue == 'F')
-		{
-			printf("+++Système : Mémoire insuffisante\n");
-		}
-		else
-		{
-			printf("+++System : Not enough memory\n");
-		}
-
-		return(EXIT_FAILURE);
-	}
-
-#	ifndef SEMAPHORES_NOMMES
-	if (pthread_setspecific(semaphore_fork_processus_courant,
-			&((*s_etat_processus).semaphore_fork)) != 0)
-#	else
-	if (pthread_setspecific(semaphore_fork_processus_courant,
-			(*s_etat_processus).semaphore_fork) != 0)
-#	endif
-	{
-		if ((*s_etat_processus).langue == 'F')
-		{
-			printf("+++Système : Mémoire insuffisante\n");
-		}
-		else
-		{
-			printf("+++System : Not enough memory\n");
-		}
-
-		return(EXIT_FAILURE);
-	}
-
 	// Initialisation d'une pile de signal pour récupérer les
 	// débordement de pile
 
@@ -3530,30 +3480,20 @@ rplinit(int argc, char *argv[], unsigned
 	pthread_mutex_destroy(&((*s_etat_processus).mutex));
 	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_post(&((*s_etat_processus).semaphore_fork));
-	sem_destroy(&((*s_etat_processus).semaphore_fork));
-#	else
-	sem_post((*s_etat_processus).semaphore_fork);
-	sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
-#	endif
+	pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));
 
 	free((*s_etat_processus).localisation);
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_destroy(&semaphore_liste_threads);
-#	else
-	sem_destroy2(semaphore_liste_threads, sem_liste_threads);
-#	endif
+	pthread_mutex_destroy(&mutex_liste_threads);
+	pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique);
+
 #	ifndef SEMAPHORES_NOMMES
 	sem_post(&semaphore_gestionnaires_signaux);
 	sem_destroy(&semaphore_gestionnaires_signaux);
-	sem_destroy(&semaphore_gestionnaires_signaux_atomique);
 #	else
 	sem_post(semaphore_gestionnaires_signaux);
 	sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
-	sem_destroy2(semaphore_gestionnaires_signaux_atomique,
-			sem_gestionnaires_signaux_atomique);
 #	endif
 
 	destruction_queue_signaux(s_etat_processus);