--- rpl/src/rpl.c	2010/04/28 06:41:06	1.20
+++ rpl/src/rpl.c	2010/06/19 15:54:51	1.30
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.15
+  RPL/2 (R) version 4.0.16
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -99,6 +99,10 @@ rplinit(int argc, char *argv[], unsigned
 	volatile int						erreur;
 	volatile unsigned char				traitement_fichier_temporaire;
 
+#	ifdef DEBUG_MEMOIRE
+	debug_memoire_initialisation();
+#	endif
+
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
@@ -184,6 +188,12 @@ rplinit(int argc, char *argv[], unsigned
 	pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
 #	ifndef SEMAPHORES_NOMMES
 	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
 #	else
@@ -447,6 +457,26 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
+	action.sa_sigaction = interruption11;
+	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+
+	if (sigaction(SIGFABORT, &action, NULL) != 0)
+	{
+		erreur = d_es_signal;
+
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("+++Système : Initialisation des signaux POSIX "
+					"impossible\n");
+		}
+		else
+		{
+			printf("+++System : Initialization of POSIX signals failed\n");
+		}
+
+		return(EXIT_FAILURE);
+	}
+
 	action.sa_sigaction = interruption8;
 	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
 
@@ -1857,6 +1887,7 @@ rplinit(int argc, char *argv[], unsigned
 			(*s_etat_processus).var_volatile_traitement_sigint = 0;
 			(*s_etat_processus).var_volatile_recursivite = 0;
 			(*s_etat_processus).var_volatile_exception_gsl = 0;
+			(*s_etat_processus).arret_depuis_abort = 0;
 
 			initialisation_allocateur(s_etat_processus);
 			initialisation_drapeaux(s_etat_processus);
@@ -2623,8 +2654,14 @@ rplinit(int argc, char *argv[], unsigned
 
 						if (erreur == d_absence_erreur)
 						{
-							erreur = evaluation(s_etat_processus,
-									(*s_etat_processus).at_exit, 'E');
+							if (((*s_etat_processus).var_volatile_alarme == 0)
+									&& ((*s_etat_processus).arret_depuis_abort
+									== 0) && ((*s_etat_processus).at_exit
+									!= NULL))
+							{
+								erreur = evaluation(s_etat_processus,
+										(*s_etat_processus).at_exit, 'E');
+							}
 						}
 
 						liberation(s_etat_processus,
@@ -2747,10 +2784,21 @@ rplinit(int argc, char *argv[], unsigned
 							}
 							else
 							{
-								kill((*(*((struct_processus_fils *)
-										(*(*((struct_liste_chainee *)
-										l_element_courant)).donnee).objet))
-										.thread).pid, SIGFSTOP);
+								if ((*s_etat_processus).arret_depuis_abort
+										== -1)
+								{
+									kill((*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, SIGFABORT);
+								}
+								else
+								{
+									kill((*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, SIGFSTOP);
+								}
 							}
 						}
 						else
@@ -2775,10 +2823,25 @@ rplinit(int argc, char *argv[], unsigned
 								}
 								else
 								{
-									pthread_kill((*(*((struct_processus_fils *)
-											(*(*((struct_liste_chainee *)
-											l_element_courant)).donnee).objet))
-											.thread).tid, SIGFSTOP);
+									if ((*s_etat_processus).arret_depuis_abort
+											== -1)
+									{
+										pthread_kill(
+												(*(*((struct_processus_fils *)
+												(*(*((struct_liste_chainee *)
+												l_element_courant)).donnee)
+												.objet)).thread).tid,
+												SIGFABORT);
+									}
+									else
+									{
+										pthread_kill(
+												(*(*((struct_processus_fils *)
+												(*(*((struct_liste_chainee *)
+												l_element_courant)).donnee)
+												.objet)).thread).tid,
+												SIGFSTOP);
+									}
 								}
 							}
 
@@ -2811,13 +2874,6 @@ rplinit(int argc, char *argv[], unsigned
 						l_element_courant = (void *)
 								(*s_etat_processus).l_base_pile_processus;
 
-						if ((*s_etat_processus)
-								.nombre_interruptions_non_affectees != 0)
-						{
-							affectation_interruptions_logicielles(
-									s_etat_processus);
-						}
-
 						for(i = 0; i < (unsigned long)
 								(*(*((struct_processus_fils *)
 								(*(*((struct_liste_chainee *)
@@ -2876,6 +2932,14 @@ rplinit(int argc, char *argv[], unsigned
 						}
 
 						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+
+						if ((*s_etat_processus)
+								.nombre_interruptions_non_affectees != 0)
+						{
+							affectation_interruptions_logicielles(
+									s_etat_processus);
+						}
+
 						nanosleep(&attente, NULL);
 						pthread_mutex_lock(&((*s_etat_processus).mutex));
 					}
@@ -3399,6 +3463,8 @@ rplinit(int argc, char *argv[], unsigned
 	}
 
 #	ifndef Cygwin
+	(*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;
+	sigaltstack(&((*s_etat_processus).pile_signal), NULL);
 	free((*s_etat_processus).pile_signal.ss_sp);
 #	endif
 
@@ -3411,6 +3477,8 @@ rplinit(int argc, char *argv[], unsigned
 	retrait_thread(s_etat_processus);
 
 	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));
@@ -3420,7 +3488,6 @@ rplinit(int argc, char *argv[], unsigned
 #	endif
 
 	free((*s_etat_processus).localisation);
-	free(s_etat_processus);
 
 #	ifndef SEMAPHORES_NOMMES
 	sem_destroy(&semaphore_liste_threads);
@@ -3438,8 +3505,11 @@ rplinit(int argc, char *argv[], unsigned
 			sem_gestionnaires_signaux_atomique);
 #	endif
 
+	free(s_etat_processus);
+
 #	ifdef DEBUG_MEMOIRE
-	debug_memoire_verification(s_etat_processus);
+	debug_memoire_verification();
+	analyse_post_mortem();
 #	endif
 
 	return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);