--- rpl/src/interruptions.c	2010/04/07 13:45:09	1.7
+++ rpl/src/interruptions.c	2010/04/28 11:05:45	1.10
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.14
+  RPL/2 (R) version 4.0.15
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -82,7 +82,11 @@ insertion_thread(struct_processus *s_eta
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -97,7 +101,11 @@ insertion_thread(struct_processus *s_eta
 	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
 			== NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -109,7 +117,11 @@ insertion_thread(struct_processus *s_eta
 
 	if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -126,7 +138,11 @@ insertion_thread(struct_processus *s_eta
 
 	liste_threads = l_nouvel_objet;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -152,7 +168,11 @@ insertion_thread_surveillance(struct_pro
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -167,7 +187,11 @@ insertion_thread_surveillance(struct_pro
 	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
 			== NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -180,7 +204,11 @@ insertion_thread_surveillance(struct_pro
 
 	liste_threads_surveillance = l_nouvel_objet;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -206,7 +234,11 @@ retrait_thread(struct_processus *s_etat_
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -236,7 +268,11 @@ retrait_thread(struct_processus *s_etat_
 
 	if (l_element_courant == NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -260,13 +296,21 @@ retrait_thread(struct_processus *s_etat_
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 
@@ -293,7 +337,11 @@ retrait_thread_surveillance(struct_proce
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -321,7 +369,11 @@ retrait_thread_surveillance(struct_proce
 
 	if (l_element_courant == NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -381,7 +433,11 @@ retrait_thread_surveillance(struct_proce
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -400,7 +456,11 @@ verrouillage_threads_concurrents(struct_
 {
 	volatile struct_liste_chainee_volatile	*l_element_courant;
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -417,8 +477,13 @@ verrouillage_threads_concurrents(struct_
 				== getpid()) && (pthread_equal((*((struct_thread *)
 				(*l_element_courant).donnee)).tid, pthread_self()) == 0))
 		{
+#			ifndef SEMAPHORES_NOMMES
 			while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
 					.donnee)).s_etat_processus).semaphore_fork)) == -1)
+#			else
+			while(sem_wait((*(*((struct_thread *) (*l_element_courant)
+					.donnee)).s_etat_processus).semaphore_fork) == -1)
+#			endif
 			{
 				if (errno != EINTR)
 				{
@@ -447,15 +512,29 @@ deverrouillage_threads_concurrents(struc
 				== getpid()) && (pthread_equal((*((struct_thread *)
 				(*l_element_courant).donnee)).tid, pthread_self()) == 0))
 		{
+#			ifndef SEMAPHORES_NOMMES
 			if (sem_post(&((*(*((struct_thread *)
 					(*l_element_courant).donnee)).s_etat_processus)
 					.semaphore_fork)) != 0)
+#			else
+			if (sem_post((*(*((struct_thread *)
+					(*l_element_courant).donnee)).s_etat_processus)
+					.semaphore_fork) != 0)
+#			endif
 			{
+#				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&semaphore_liste_threads) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
+#				else
+				if (sem_post(semaphore_liste_threads) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+#				endif
 
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -465,7 +544,11 @@ deverrouillage_threads_concurrents(struc
 		l_element_courant = (*l_element_courant).suivant;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return;
@@ -498,7 +581,11 @@ liberation_threads(struct_processus *s_e
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1163,8 +1250,13 @@ liberation_threads(struct_processus *s_e
 
 			liberation_allocateur(s_etat_processus);
 
+#			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
 
 			free(s_etat_processus);
 
@@ -1235,7 +1327,11 @@ liberation_threads(struct_processus *s_e
 
 	liste_threads_surveillance = NULL;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -1358,7 +1454,11 @@ verrouillage_gestionnaire_signaux()
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1368,21 +1468,33 @@ verrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux) == -1)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux) == -1)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Lock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	else
+	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Lock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
@@ -1397,7 +1509,11 @@ verrouillage_gestionnaire_signaux()
 		// par un thread concurrent. On essaye donc de le bloquer jusqu'à
 		// ce que ce soit possible.
 
+#		ifndef SEMAPHORES_NOMMES
 		while(sem_trywait(&semaphore_liste_threads) == -1)
+#		else
+		while(sem_trywait(semaphore_liste_threads) == -1)
+#		endif
 		{
 			if ((errno != EINTR) && (errno != EAGAIN))
 			{
@@ -1441,7 +1557,11 @@ deverrouillage_gestionnaire_signaux()
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1451,14 +1571,22 @@ deverrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	else
+	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1468,7 +1596,11 @@ deverrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
@@ -1491,7 +1623,11 @@ deverrouillage_gestionnaire_signaux()
 
 	if (semaphore == 1)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		if (sem_post(&semaphore_liste_threads) != 0)
+#		else
+		if (sem_post(semaphore_liste_threads) != 0)
+#		endif
 		{
 			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 
@@ -1823,9 +1959,18 @@ interruption5(int signal, siginfo_t *sig
 
 		if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
 		{
-			printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
-					(unsigned long long) pthread_self());
-			fflush(stdout);
+			if (signal == SIGFSTOP)
+			{
+				printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
+						(unsigned long long) pthread_self());
+				fflush(stdout);
+			}
+			else
+			{
+				printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
+						(unsigned long long) pthread_self());
+				fflush(stdout);
+			}
 		}
 
 		/*
@@ -1835,13 +1980,21 @@ interruption5(int signal, siginfo_t *sig
 		 * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
 		 */
 
-		if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
+		if (signal == SIGFSTOP)
 		{
-			(*s_etat_processus).var_volatile_requete_arret = -1;
+			if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
+			{
+				(*s_etat_processus).var_volatile_requete_arret = -1;
+			}
+			else
+			{
+				(*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
+			}
 		}
 		else
 		{
-			(*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
+			(*s_etat_processus).var_volatile_requete_arret = -1;
+			(*s_etat_processus).arret_depuis_abort = -1;
 		}
 	}
 	else
@@ -1850,7 +2003,7 @@ interruption5(int signal, siginfo_t *sig
 
 		if (recherche_thread_principal(getpid(), &thread) == d_vrai)
 		{
-			pthread_kill(thread, SIGFSTOP);
+			pthread_kill(thread, signal);
 			deverrouillage_gestionnaire_signaux();
 			return;
 		}