--- rpl/src/gestion_interruptions.c	2010/01/26 15:22:45	1.1
+++ rpl/src/gestion_interruptions.c	2020/01/10 11:15:42	1.70
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -39,19 +39,15 @@ void
 affectation_interruptions_logicielles(struct_processus *s_etat_processus)
 {
 	int								interruption;
+	int								ios;
 
 	sig_atomic_t					registre;
 
 	volatile struct_liste_chainee	*l_element_courant;
+	struct_liste_chainee			*l_element;
 
 	struct_objet					*s_objet_processus;
 
-	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_processus;
-		return;
-	}
-
 	if ((*s_etat_processus).var_volatile_requete_arret == -1)
 	{
 		// Si une requête d'arrêt est reçue par le processus durant la
@@ -59,11 +55,15 @@ affectation_interruptions_logicielles(st
 		// processus peut déjà être libérée par le thread de surveillance.
 
 		(*s_etat_processus).nombre_interruptions_non_affectees = 0;
+		return;
+	}
 
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+	if ((ios = pthread_mutex_trylock(&((*s_etat_processus)
+			.mutex_pile_processus))) != 0)
+	{
+		if (ios != EBUSY)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
 		}
 
 		return;
@@ -83,7 +83,7 @@ affectation_interruptions_logicielles(st
 
 		if ((*(*l_element_courant).donnee).type != PRC)
 		{
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
 
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
@@ -92,7 +92,7 @@ affectation_interruptions_logicielles(st
 		if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
 				(*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
 		{
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
 
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
@@ -124,10 +124,11 @@ affectation_interruptions_logicielles(st
 				if ((interruption < 1) || (interruption >
 						d_NOMBRE_INTERRUPTIONS))
 				{
-					pthread_mutex_unlock(&((*s_etat_processus).mutex));
 					pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread)
 							.mutex));
+					pthread_mutex_unlock(&((*s_etat_processus)
+							.mutex_pile_processus));
 
 					(*s_etat_processus).erreur_systeme =
 							d_es_interruption_invalide;
@@ -145,30 +146,61 @@ affectation_interruptions_logicielles(st
 					if ((s_objet_processus = copie_objet(s_etat_processus,
 							(*l_element_courant).donnee, 'P')) == NULL)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
 						pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 								(*(*l_element_courant).donnee).objet)).thread)
 								.mutex));
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
 
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
 						return;
 					}
 
+					// Pile LIFO
+
 					if (empilement(s_etat_processus, &((*s_etat_processus)
 							.pile_origine_interruptions[interruption - 1]),
 							s_objet_processus) == d_erreur)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
 						pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 								(*(*l_element_courant).donnee).objet)).thread)
 								.mutex));
+
+						if (pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus)) != 0)
+						{
+							(*s_etat_processus).erreur_systeme = d_es_processus;
+							return;
+						}
+
 						return;
 					}
 
 					(*s_etat_processus).queue_interruptions[interruption - 1]++;
 					(*s_etat_processus).nombre_interruptions_en_queue++;
 
+					// Transformation en FIFO
+
+					if ((*s_etat_processus).queue_interruptions
+							[interruption - 1] > 1)
+					{
+						l_element = (*s_etat_processus)
+								.pile_origine_interruptions[interruption - 1];
+
+						while((*l_element).suivant != NULL)
+						{
+							l_element = (*l_element).suivant;
+						}
+
+						(*l_element).suivant = (*s_etat_processus)
+								.pile_origine_interruptions[interruption - 1];
+						(*s_etat_processus).pile_origine_interruptions
+								[interruption - 1] =
+								(*(*l_element).suivant).suivant;
+						(*(*l_element).suivant).suivant = NULL;
+					}
+
 					if ((*s_etat_processus).debug == d_vrai)
 						if (((*s_etat_processus).type_debug &
 								d_traitement_interruption) != 0)
@@ -229,9 +261,10 @@ affectation_interruptions_logicielles(st
 			}
 			else
 			{
-				pthread_mutex_unlock(&((*s_etat_processus).mutex));
 				pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 						(*(*l_element_courant).donnee).objet)).thread).mutex));
+				pthread_mutex_unlock(&((*s_etat_processus)
+						.mutex_pile_processus));
 
 				if (registre == 0)
 				{
@@ -253,8 +286,6 @@ affectation_interruptions_logicielles(st
 		if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 				(*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
 		{
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
-
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
@@ -262,7 +293,7 @@ affectation_interruptions_logicielles(st
 		l_element_courant = (*l_element_courant).suivant;
 	}
 
-	if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return;