--- rpl/src/gestion_processus.c	2010/05/24 10:58:30	1.12
+++ rpl/src/gestion_processus.c	2016/07/21 15:22:52	1.85
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.16
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.25
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -40,7 +40,6 @@
 void *
 surveillance_processus(void *argument)
 {
-	int								iostat;
 	int								status;
 
 	integer8						nombre_donnees;
@@ -48,16 +47,12 @@ surveillance_processus(void *argument)
 	logical1						drapeau;
 	logical1						drapeau_fin;
 	logical1						drapeau_fin_scrutation;
-	logical1						drapeau_interruptions_traitees;
-	logical1						drapeau_objets_traites;
+	logical1						drapeau_elements_traites;
 
 	pid_t							pid;
-	pid_t							pid_candidat;
-
-	pthread_t						tid_candidat;
-
-	sigset_t						masque;
+	pid_t							pid_erreur;
 
+	ssize_t							iostat;
 	ssize_t							longueur_ecriture;
 
 	struct_descripteur_thread		*s_argument_thread;
@@ -71,29 +66,38 @@ surveillance_processus(void *argument)
 
 	unsigned char					caractere;
 
-	unsigned int					tampon_erreur;
+	int								tampon_erreur_execution;
+	int								tampon_erreur_systeme;
 
-	sigemptyset(&masque);
-	sigaddset(&masque, SIGINJECT);
-	sigaddset(&masque, SIGFSTOP);
-	sigaddset(&masque, SIGFABORT);
-	sigaddset(&masque, SIGURG);
-	sigaddset(&masque, SIGALRM);
-	sigaddset(&masque, SIGCONT);
-	sigaddset(&masque, SIGINT);
-	pthread_sigmask(SIG_BLOCK, &masque, NULL);
+	sigset_t						set;
+
+	sigfillset(&set);
+	pthread_sigmask(SIG_BLOCK, &set, NULL);
 
 	s_argument_thread = argument;
 	s_etat_processus = (*s_argument_thread).s_etat_processus;
+
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		BUG(1, uprintf("General mutex error!\n"));
+	}
+
+	nombre_thread_surveillance_processus++;
 	insertion_thread_surveillance(s_etat_processus, s_argument_thread);
 
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		BUG(1, uprintf("General mutex error!\n"));
+	}
+
 	attente.tv_sec = 0;
 	attente.tv_nsec = GRANULARITE_us * 1000;
 
 	status = 0;
 
-	drapeau_interruptions_traitees = d_faux;
-	drapeau_objets_traites = d_faux;
+	drapeau_elements_traites = d_faux;
 
 	if ((*s_etat_processus).debug == d_vrai)
 		if (((*s_etat_processus).type_debug &
@@ -138,13 +142,12 @@ surveillance_processus(void *argument)
 	 */
 
 	while(read_atomic(s_etat_processus,
-			(*s_argument_thread).pipe_nombre_objets_attente[0],
+			(*s_argument_thread).pipe_nombre_elements_attente[0],
 			&caractere, sizeof(caractere)) == 0)
 	{
 		if ((*s_etat_processus).var_volatile_requete_arret != 0)
 		{
-			drapeau_objets_traites = d_vrai;
-			drapeau_interruptions_traitees = d_vrai;
+			drapeau_elements_traites = d_vrai;
 		}
 
 		nanosleep(&attente, NULL);
@@ -158,373 +161,238 @@ surveillance_processus(void *argument)
 			 * Le processus est un processus détaché.
 			 */
 
-			// Scrutation de l'envoi de données par le fils.
-
-			pid_candidat = 0;
-
-			if (drapeau_objets_traites == d_vrai)
+			if (drapeau_elements_traites == d_vrai)
 			{
 				nanosleep(&attente, NULL);
 			}
 			else if ((iostat = read_atomic(s_etat_processus,
-					(*s_argument_thread).pipe_nombre_objets_attente[0],
-					&pid_candidat, sizeof(pid_candidat))) == 0)
+					(*s_argument_thread).pipe_nombre_elements_attente[0],
+					&caractere, sizeof(caractere))) == 0)
 			{
 				// Rien dans le pipe
-
 				nanosleep(&attente, NULL);
 			}
-			else if (iostat != sizeof(pid_candidat))
+			else if (iostat == sizeof(caractere))
 			{
-				(*s_etat_processus).erreur_systeme_processus_fils =
-						d_es_processus;
-			}
-			else
-			{
-				// Un pid est dans le pipe. On vérifie que les deux pids
-				// correspondent.
+				// Un objet supplémentaire est dans le pipe correspondant
+				// au processus surveillé par ce thread.
 
-				if (pid_candidat == -2)
-				{
-					drapeau_objets_traites = d_vrai;
-				}
-				else if (pid_candidat == -1)
+				if (pthread_mutex_lock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
+					(*s_etat_processus).erreur_systeme_processus_fils =
+							d_es_processus;
 				}
-				else if ((iostat = read_atomic(s_etat_processus,
-						(*s_argument_thread).pipe_nombre_objets_attente[0],
-						&pid_candidat, sizeof(pid_candidat))) ==
-						sizeof(pid_candidat))
+
+				l_element_courant = (struct_liste_chainee *)
+						(*s_etat_processus).l_base_pile_processus;
+
+				while(l_element_courant != NULL)
 				{
-					if ((*s_argument_thread).pid != pid_candidat)
+					if ((*(*((struct_processus_fils *)
+							(*(*l_element_courant).donnee).objet))
+							.thread).processus_detache == d_faux)
 					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-						BUG(1, printf("Spurious process identifier"));
+						l_element_courant = (*l_element_courant)
+								.suivant;
+						continue;
 					}
 
-					// Un objet supplémentaire est dans le pipe correspondant
-					// au processus surveillé par ce thread.
-
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+					if ((*(*((struct_processus_fils *)
+							(*(*l_element_courant).donnee).objet))
+							.thread).pid == (*s_argument_thread).pid)
 					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
+						break;
 					}
-					else
-					{
-						l_element_courant = (struct_liste_chainee *)
-								(*s_etat_processus).l_base_pile_processus;
 
-						while(l_element_courant != NULL)
-						{
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).processus_detache == d_faux)
-							{
-								l_element_courant = (*l_element_courant)
-										.suivant;
-								continue;
-							}
+					l_element_courant = (*l_element_courant).suivant;
+				}
 
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).pid == pid_candidat)
-							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
-								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Données en provenance "
-												"du processus %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Data from process %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
-								}
+				BUG(l_element_courant == NULL,
+						printf("Process or thread not found"));
 
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+				switch(caractere)
+				{
+					case 1:
+					case 2:
+					{
+						if ((*s_etat_processus).debug == d_vrai)
+							if (((*s_etat_processus).type_debug &
+									d_debug_processus) != 0)
+						{
+							if ((*s_etat_processus).langue == 'F')
+							{
+								if (caractere == 1)
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Données en provenance "
+											"du processus %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
-
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).nombre_objets_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								else
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Interrution logicielle "
+											"en provenance du processus "
+											"%d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
 
-								while((longueur_ecriture =
-										write_atomic(s_etat_processus,
-										(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).pipe_acquittement[1], "-",
-										sizeof(unsigned char))) !=
-										sizeof(unsigned char))
+								fflush(stdout);
+							}
+							else
+							{
+								if (caractere == 1)
 								{
-									if (longueur_ecriture == -1)
-									{
-										(*s_etat_processus)
-												.erreur_systeme_processus_fils =
-												d_es_processus;
-									}
+									printf("[%d] Data from process %d\n",
+											(int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
-
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
+								else
 								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Données acquittées "
-												"en provenance du "
-												"processus %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Data acknowklegment "
-												"from process %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
+									printf("[%d] Software interrupt "
+											"from process %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
 
-								break;
+								fflush(stdout);
 							}
-
-							l_element_courant = (*l_element_courant).suivant;
 						}
 
-						BUG(l_element_courant == NULL,
-								printf("Process or thread not found"));
-
-						if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
-								!= 0)
+						if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).mutex)) != 0)
 						{
-							(*s_etat_processus).erreur_systeme_processus_fils =
+							(*s_etat_processus).erreur_systeme =
 									d_es_processus;
 						}
 
-						pthread_kill((*s_argument_thread).thread_pere,
-								SIGINJECT);
-					}
-				}
-				else
-				{
-					(*s_etat_processus).erreur_systeme_processus_fils =
-							d_es_processus;
-				}
-			}
-
-			// Scrutation de l'envoi d'interruptions par le fils.
-
-			if (drapeau_interruptions_traitees == d_vrai)
-			{
-				nanosleep(&attente, NULL);
-			}
-			else if ((iostat = read_atomic(s_etat_processus,
-					(*s_argument_thread).pipe_nombre_interruptions_attente[0],
-					&pid_candidat, sizeof(pid_candidat))) == 0)
-			{
-				// Rien dans le pipe
+						if (caractere == 1)
+						{
+							(*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).nombre_objets_dans_pipe++;
+						}
+						else
+						{
+							(*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+							 		.thread).nombre_interruptions_dans_pipe++;
 
-				nanosleep(&attente, NULL);
-			}
-			else if (iostat != sizeof(pid_candidat))
-			{
-				(*s_etat_processus).erreur_systeme_processus_fils =
-						d_es_processus;
-			}
-			else
-			{
-				// Un pid est dans le pipe. On vérifie que les deux pids
-				// correspondent.
+							if (pthread_mutex_lock(&((*s_etat_processus)
+									.mutex_interruptions)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+								 		d_es_processus;
+							}
 
-				if (pid_candidat == -2)
-				{
-					drapeau_interruptions_traitees = d_vrai;
-				}
-				else if (pid_candidat == -1)
-				{
-				}
-				else if ((iostat = read_atomic(s_etat_processus,
-						(*s_argument_thread).pipe_nombre_interruptions_attente
-						[0], &pid_candidat, sizeof(pid_candidat)))
-						== sizeof(pid_candidat))
-				{
-					if ((*s_argument_thread).pid != pid_candidat)
-					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-						BUG(1, printf("Spurious interrupt"));
-					}
+							(*s_etat_processus)
+									.nombre_interruptions_non_affectees++;
 
-					// Une interruption supplémentaire est dans le pipe
-					// correspondant au processus surveillé par ce thread.
+							if (pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_interruptions)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+							}
+						}
 
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-					}
-					else
-					{
-						l_element_courant = (struct_liste_chainee *)
-								(*s_etat_processus).l_base_pile_processus;
+						if (pthread_mutex_unlock(
+								&((*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).mutex)) != 0)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
+						}
 
-						while(l_element_courant != NULL)
+						while((longueur_ecriture =
+								write_atomic(s_etat_processus,
+								(*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).pipe_acquittement[1], "-",
+								sizeof(unsigned char))) !=
+								sizeof(unsigned char))
 						{
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).processus_detache == d_faux)
+							if (longueur_ecriture == -1)
 							{
-								l_element_courant = (*l_element_courant)
-										.suivant;
-								continue;
+								(*s_etat_processus)
+										.erreur_systeme_processus_fils =
+										d_es_processus;
 							}
+						}
 
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).pid == pid_candidat)
+						if ((*s_etat_processus).debug == d_vrai)
+							if (((*s_etat_processus).type_debug &
+									d_debug_processus) != 0)
+						{
+							if ((*s_etat_processus).langue == 'F')
 							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_traitement_interruption) != 0)
+								if (caractere == 1)
 								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Interrution logicielle "
-												"en provenance du processus "
-												"%d\n", (int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Software interrupt "
-												"from process %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
+									printf("[%d] Données acquittées "
+											"en provenance du "
+											"processus %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
-
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								else
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Interruption logicielle "
+											"acquittée en provenance "
+											"du processus %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
 
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee)
-										.objet)).thread)
-										.nombre_interruptions_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-								}
-
-								(*s_etat_processus)
-										.nombre_interruptions_non_affectees++;
-
-								while((longueur_ecriture =
-										write_atomic(s_etat_processus,
-										(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).pipe_acquittement[1], "-",
-										sizeof(unsigned char))) !=
-										sizeof(unsigned char))
+								fflush(stdout);
+							}
+							else
+							{
+								if (caractere == 1)
 								{
-									if (longueur_ecriture == -1)
-									{
-										(*s_etat_processus)
-												.erreur_systeme_processus_fils =
-												d_es_processus;
-									}
+									printf("[%d] Data acknowklegment "
+											"from process %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
-
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_traitement_interruption) != 0)
+								else
 								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Interruption logicielle "
-												"acquittée en provenance "
-												"du processus %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Software interrupt "
-												"acknowklegment from "
-												"process %d\n",
-												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
-									}
+									printf("[%d] Software interrupt "
+											"acknowklegment from "
+											"process %d\n", (int) getpid(),
+											(int) (*s_argument_thread).pid);
 								}
 
-								break;
+								fflush(stdout);
 							}
-
-							l_element_courant = (*l_element_courant).suivant;
 						}
 
-						BUG(l_element_courant == NULL,
-								printf("Process or thread not found"));
+						envoi_signal_thread((*s_argument_thread).thread_pere,
+								rpl_siginject);
+						break;
+					}
 
-						if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
-								!= 0)
-						{
-							(*s_etat_processus).erreur_systeme_processus_fils =
-									d_es_processus;
-						}
+					case 0:
+					{
+						break;
+					}
 
-						pthread_kill((*s_argument_thread).thread_pere,
-								SIGINJECT);
+					default:
+					{
+						(*s_etat_processus).erreur_systeme_processus_fils =
+								d_es_processus;
+						BUG(1, printf("Spurious interprocess data"));
 					}
 				}
-				else
+
+				if (pthread_mutex_unlock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme_processus_fils =
 							d_es_processus;
 				}
 			}
+			else
+			{
+				perror("read");
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+			}
 
 			if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0)
 			{
@@ -548,376 +416,258 @@ surveillance_processus(void *argument)
 			 * Le processus n'est pas détaché.
 			 */
 
-			// Scrutation de l'envoi de données par le fils.
-
-			tid_candidat = (pthread_t) 0;
-
-			if (drapeau_objets_traites == d_vrai)
+			if (drapeau_elements_traites == d_vrai)
 			{
 				nanosleep(&attente, NULL);
 			}
 			else if ((iostat = read_atomic(s_etat_processus,
-					(*s_argument_thread).pipe_nombre_objets_attente[0],
-					&tid_candidat, sizeof(tid_candidat))) == 0)
+					(*s_argument_thread).pipe_nombre_elements_attente[0],
+					&caractere, sizeof(caractere))) == 0)
 			{
 				// Rien dans le pipe
-
 				nanosleep(&attente, NULL);
 			}
-			else if (iostat != sizeof(tid_candidat))
-			{
-				(*s_etat_processus).erreur_systeme_processus_fils =
-						d_es_processus;
-			}
-			else
+			else if (iostat == sizeof(caractere))
 			{
-				// Un pid est dans le pipe. On vérifie que les deux pids
-				// correspondent.
+				// Un objet supplémentaire est dans le pipe correspondant
+				// au processus surveillé par ce thread.
 
-				if (tid_candidat == (pthread_t) -2)
-				{
-					drapeau_objets_traites = d_vrai;
-				}
-				else if (tid_candidat == (pthread_t) -1)
+				if (pthread_mutex_lock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
+					(*s_etat_processus).erreur_systeme_processus_fils =
+							d_es_processus;
 				}
-				else if ((iostat = read_atomic(s_etat_processus,
-						(*s_argument_thread).pipe_nombre_objets_attente[0],
-						&tid_candidat, sizeof(tid_candidat))) ==
-						sizeof(tid_candidat))
+
+				l_element_courant = (struct_liste_chainee *)
+						(*s_etat_processus).l_base_pile_processus;
+
+				while(l_element_courant != NULL)
 				{
-					if (pthread_equal((*s_argument_thread).tid,
-								tid_candidat) == 0)
+					if ((*(*((struct_processus_fils *)
+							(*(*l_element_courant).donnee).objet))
+							.thread).processus_detache == d_vrai)
 					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-						BUG(1, printf("Spurious thread identifier"));
+						l_element_courant = (*l_element_courant).suivant;
+						continue;
 					}
 
-					// Un objet supplémentaire est dans le pipe correspondant
-					// au processus surveillé par ce thread.
-
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+					if ((*(*((struct_processus_fils *)
+							(*(*l_element_courant).donnee).objet))
+							.thread).tid == (*s_argument_thread).tid)
 					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
+						break;
 					}
-					else
-					{
-						l_element_courant = (struct_liste_chainee *)
-								(*s_etat_processus).l_base_pile_processus;
 
-						while(l_element_courant != NULL)
-						{
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).processus_detache == d_vrai)
-							{
-								l_element_courant = (*l_element_courant)
-										.suivant;
-								continue;
-							}
+					l_element_courant = (*l_element_courant).suivant;
+				}
 
-							if (pthread_equal((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).tid, tid_candidat) != 0)
-							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
-								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Données en provenance "
-												"du thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Data from thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-								}
+				BUG(l_element_courant == NULL,
+						printf("Process or thread not found"));
 
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+				switch(caractere)
+				{
+					case 1:
+					case 2:
+					{
+						if ((*s_etat_processus).debug == d_vrai)
+							if (((*s_etat_processus).type_debug &
+									d_debug_processus) != 0)
+						{
+							if ((*s_etat_processus).langue == 'F')
+							{
+								if (caractere == 1)
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Données en provenance "
+											"du thread %llu\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
-
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).nombre_objets_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								else
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Interrution logicielle "
+											"en provenance du thread "
+											"%llu\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
 
-								while((longueur_ecriture =
-										write_atomic(s_etat_processus,
-										(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).pipe_acquittement[1], "-",
-										sizeof(unsigned char))) !=
-										sizeof(unsigned char))
+								fflush(stdout);
+							}
+							else
+							{
+								if (caractere == 1)
 								{
-									if (longueur_ecriture == -1)
-									{
-										(*s_etat_processus)
-												.erreur_systeme_processus_fils =
-												d_es_processus;
-									}
+									printf("[%d] Data from thread %llu\n",
+											(int) getpid(), (unsigned long long)
+											(*s_argument_thread).tid);
 								}
-
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
+								else
 								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Données acquittées "
-												"en provenance du thread "
-												"%llu\n", (int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Data acknowklegment "
-												"from thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
+									printf("[%d] Software interrupt "
+											"from thread %llu\n",
+											(int) getpid(), (unsigned long long)
+											(*s_argument_thread).tid);
 								}
 
-								break;
+								fflush(stdout);
 							}
-
-							l_element_courant = (*l_element_courant).suivant;
 						}
 
-						BUG(l_element_courant == NULL,
-								printf("Process or thread not found\n"));
-
-						if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
-								!= 0)
+						if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).mutex)) != 0)
 						{
-							(*s_etat_processus).erreur_systeme_processus_fils =
+							(*s_etat_processus).erreur_systeme =
 									d_es_processus;
 						}
-					}
-				}
-				else
-				{
-					(*s_etat_processus).erreur_systeme_processus_fils =
-							d_es_processus;
-				}
-			}
-
-			// Scrutation de l'envoi d'interruptions par le fils.
 
-			if (drapeau_interruptions_traitees == d_vrai)
-			{
-				nanosleep(&attente, NULL);
-			}
-			else if ((iostat = read_atomic(s_etat_processus,
-					(*s_argument_thread).pipe_nombre_interruptions_attente[0],
-					&tid_candidat, sizeof(tid_candidat))) == 0)
-			{
-				// Rien dans le pipe
+						if (caractere == 1)
+						{
+							(*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).nombre_objets_dans_pipe++;
+						}
+						else
+						{
+							(*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+							 		.thread).nombre_interruptions_dans_pipe++;
 
-				nanosleep(&attente, NULL);
-			}
-			else if (iostat != sizeof(tid_candidat))
-			{
-				(*s_etat_processus).erreur_systeme_processus_fils =
-						d_es_processus;
-			}
-			else
-			{
-				// Un pid est dans le pipe. On vérifie que les deux pids
-				// correspondent.
+							if (pthread_mutex_lock(&((*s_etat_processus)
+									.mutex_interruptions)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+							}
 
-				if (tid_candidat == (pthread_t) -2)
-				{
-					drapeau_interruptions_traitees = d_vrai;
-				}
-				else if (tid_candidat == (pthread_t) -1)
-				{
-				}
-				else if ((iostat = read_atomic(s_etat_processus,
-						(*s_argument_thread).pipe_nombre_interruptions_attente
-						[0], &tid_candidat, sizeof(tid_candidat))) ==
-						sizeof(tid_candidat))
-				{
-					if (pthread_equal((*s_argument_thread).tid,
-							tid_candidat) == 0)
-					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-						BUG(1, printf("Spurious interrupt"));
-					}
+							(*s_etat_processus)
+									.nombre_interruptions_non_affectees++;
 
-					// Une interruption supplémentaire est dans le pipe
-					// correspondant au processus surveillé par ce thread.
+							if (pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_interruptions)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+							}
+						}
 
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme_processus_fils =
-								d_es_processus;
-					}
-					else
-					{
-						l_element_courant = (struct_liste_chainee *)
-								(*s_etat_processus).l_base_pile_processus;
+						if (pthread_mutex_unlock(
+								&((*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).mutex)) != 0)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
+						}
 
-						while(l_element_courant != NULL)
+						while((longueur_ecriture =
+								write_atomic(s_etat_processus,
+								(*(*((struct_processus_fils *)
+								(*(*l_element_courant).donnee).objet))
+								.thread).pipe_acquittement[1], "-",
+								sizeof(unsigned char))) !=
+								sizeof(unsigned char))
 						{
-							if ((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).processus_detache == d_vrai)
+							if (longueur_ecriture == -1)
 							{
-								l_element_courant = (*l_element_courant)
-										.suivant;
-								continue;
+								(*s_etat_processus)
+										.erreur_systeme_processus_fils =
+										d_es_processus;
 							}
+						}
 
-							if (pthread_equal((*(*((struct_processus_fils *)
-									(*(*l_element_courant).donnee).objet))
-									.thread).tid, tid_candidat) != 0)
+						if ((*s_etat_processus).debug == d_vrai)
+							if (((*s_etat_processus).type_debug &
+									d_debug_processus) != 0)
+						{
+							if ((*s_etat_processus).langue == 'F')
 							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
+								if (caractere == 1)
 								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Interrution logicielle "
-												"en provenance du thread "
-												"%llu\n", (int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Software interrupt "
-												"from thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
+									printf("[%d] Données acquittées "
+											"en provenance du "
+											"thread %llu\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
-
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								else
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Interruption logicielle "
+											"acquittée en provenance "
+											"du thread %llu\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
 
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee)
-										.objet)).thread)
-										.nombre_interruptions_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								fflush(stdout);
+							}
+							else
+							{
+								if (caractere == 1)
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									printf("[%d] Data acknowklegment "
+											"from thread %d\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
-
-								(*s_etat_processus)
-										.nombre_interruptions_non_affectees++;
-
-								while((longueur_ecriture =
-										write_atomic(s_etat_processus,
-										(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).pipe_acquittement[1], "-",
-										sizeof(unsigned char))) !=
-										sizeof(unsigned char))
+								else
 								{
-									if (longueur_ecriture == -1)
-									{
-										(*s_etat_processus)
-												.erreur_systeme_processus_fils =
-												d_es_processus;
-									}
+									printf("[%d] Software interrupt "
+											"acknowklegment from "
+											"thread %d\n", (int) getpid(),
+											(unsigned long long)
+											(*s_argument_thread).tid);
 								}
 
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_traitement_interruption) != 0)
-								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Interruption logicielle "
-												"acquittée en provenance "
-												"du thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Software interrupt "
-												"acknowklegment from "
-												"thread %llu\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-								}
-
-								break;
+								fflush(stdout);
 							}
+						}
 
-							l_element_courant = (*l_element_courant).suivant;
+						if (pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus)) != 0)
+						{
+							(*s_etat_processus).erreur_systeme_processus_fils =
+									d_es_processus;
 						}
 
-						BUG(l_element_courant == NULL,
-								printf("Process or thread not found"));
+						envoi_signal_thread((*s_argument_thread).thread_pere,
+								rpl_siginject);
 
-						if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
-								!= 0)
+						if (pthread_mutex_lock(&((*s_etat_processus)
+								.mutex_pile_processus)) != 0)
 						{
 							(*s_etat_processus).erreur_systeme_processus_fils =
 									d_es_processus;
 						}
+
+						break;
+					}
+
+					case 0:
+					{
+						break;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_systeme_processus_fils =
+								d_es_processus;
+						BUG(1, printf("Spurious interprocess data"));
 					}
 				}
-				else
+
+				if (pthread_mutex_unlock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme_processus_fils =
 							d_es_processus;
 				}
 			}
+			else
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+			}
 
 			if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
 			{
@@ -951,7 +701,7 @@ surveillance_processus(void *argument)
 	 * reste plus rien dans les tuyaux...
 	 */
 
-	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
 	{
 		(*s_etat_processus).erreur_systeme_processus_fils =
 				d_es_processus;
@@ -999,384 +749,251 @@ surveillance_processus(void *argument)
 		l_element_courant = (struct_liste_chainee *)
 				(*s_etat_processus).l_base_pile_processus;
 
-		if (drapeau_objets_traites == d_faux)
+		if (drapeau_elements_traites == d_faux)
 		{
-			if ((*s_argument_thread).processus_detache == d_vrai)
+			while(l_element_courant != NULL)
 			{
-				while(l_element_courant != NULL)
+				if ((*(*((struct_processus_fils *) (*(*l_element_courant)
+						.donnee).objet)).thread).processus_detache
+						== d_vrai)
 				{
 					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
-							.donnee).objet)).thread).processus_detache
-							== d_faux)
-					{
-						l_element_courant = (*l_element_courant).suivant;
-						continue;
-					}
-
-					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
 							.donnee).objet)).thread).pid ==
 							(*s_argument_thread).pid)
 					{
 						while(read_atomic(s_etat_processus, (*s_argument_thread)
-								.pipe_nombre_objets_attente[0],
-								&pid_candidat, sizeof(pid_candidat)) ==
-								sizeof(pid_candidat))
+								.pipe_nombre_elements_attente[0],
+								&caractere, sizeof(caractere)) ==
+								sizeof(caractere))
 						{
-							/*
-							 * -1 est renvoyé par l'instruction SWI
-							 */
-
-							if (pid_candidat == -2)
-							{
-								break;
-							}
-							else if (pid_candidat == -1)
+							if (caractere == 0)
 							{
+								continue;
 							}
-							else if (read_atomic(s_etat_processus,
-									(*s_argument_thread)
-									.pipe_nombre_objets_attente[0],
-									&pid_candidat, sizeof(pid_candidat)) ==
-									sizeof(pid_candidat))
+
+							if ((*s_etat_processus).debug == d_vrai)
+								if (((*s_etat_processus).type_debug &
+										d_debug_processus) != 0)
 							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
+								if ((*s_etat_processus).langue == 'F')
 								{
-									if ((*s_etat_processus).langue == 'F')
+									if (caractere == 1)
 									{
 										printf("[%d] Données en provenance du "
 												"processus %d (processus "
 												"arrêté)\n", (int) getpid(),
 												(int) (*s_argument_thread).pid);
-										fflush(stdout);
 									}
 									else
 									{
+										printf("[%d] Interruption en "
+												"provenance du "
+												"processus %d (processus "
+												"arrêté)\n", (int) getpid(),
+												(int) (*s_argument_thread).pid);
+									}
+
+									fflush(stdout);
+								}
+								else
+								{
+									if (caractere == 1)
+									{
 										printf("[%d] Data from process %d "
 												"(processus stopped)\n",
 												(int) getpid(),
 												(int) (*s_argument_thread).pid);
-										fflush(stdout);
 									}
+									else
+									{
+										printf("[%d] Interrupt from process %d "
+												"(processus stopped)\n",
+												(int) getpid(),
+												(int) (*s_argument_thread).pid);
+									}
+
+									fflush(stdout);
 								}
+							}
 
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
+							if (pthread_mutex_lock(
+									&((*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).mutex)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+							}
+
+							if (caractere == 1)
+							{
+								(*(*((struct_processus_fils *)
+										(*(*l_element_courant).donnee).objet))
+										.thread).nombre_objets_dans_pipe++;
+							}
+							else
+							{
+								(*(*((struct_processus_fils *)
 										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+										.thread)
+										.nombre_interruptions_dans_pipe++;
+
+								if (pthread_mutex_lock(&((*s_etat_processus)
+										.mutex_interruptions)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
 								}
 
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).nombre_objets_dans_pipe++;
+								(*s_etat_processus)
+										.nombre_interruptions_non_affectees++;
 
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								if (pthread_mutex_unlock(&((*s_etat_processus)
+										.mutex_interruptions)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
 								}
 							}
+
+							if (pthread_mutex_unlock(
+									&((*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).mutex)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+							}
 						}
 
 						break;
 					}
-
-					l_element_courant = (*l_element_courant).suivant;
 				}
-			}
-			else
-			{
-				while(l_element_courant != NULL)
+				else
 				{
 					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
-							.donnee).objet)).thread).processus_detache
-							== d_vrai)
-					{
-						l_element_courant = (*l_element_courant).suivant;
-						continue;
-					}
-
-					if (pthread_equal((*(*((struct_processus_fils *)
-							(*(*l_element_courant).donnee).objet)).thread).tid,
-							(*s_argument_thread).tid) != 0)
+							.donnee).objet)).thread).tid ==
+							(*s_argument_thread).tid)
 					{
 						while(read_atomic(s_etat_processus, (*s_argument_thread)
-								.pipe_nombre_objets_attente[0],
-								&tid_candidat, sizeof(tid_candidat)) ==
-								sizeof(tid_candidat))
+								.pipe_nombre_elements_attente[0],
+								&caractere, sizeof(caractere)) ==
+								sizeof(caractere))
 						{
-							/*
-							 * -1 est renvoyé par l'instruction SWI
-							 */
-
-							if (tid_candidat == (pthread_t) -2)
-							{
-								break;
-							}
-							else if (tid_candidat == (pthread_t) -1)
+							if (caractere == 0)
 							{
+								continue;
 							}
-							else if (read_atomic(s_etat_processus,
-									(*s_argument_thread)
-									.pipe_nombre_objets_attente[0],
-									&tid_candidat, sizeof(tid_candidat)) ==
-									sizeof(tid_candidat))
+
+							if ((*s_etat_processus).debug == d_vrai)
+								if (((*s_etat_processus).type_debug &
+										d_debug_processus) != 0)
 							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_debug_processus) != 0)
+								if ((*s_etat_processus).langue == 'F')
 								{
-									if ((*s_etat_processus).langue == 'F')
+									if (caractere == 1)
 									{
 										printf("[%d] Données en provenance du "
-												"thread %llu (thread "
+												"thread %llu (processus "
 												"arrêté)\n", (int) getpid(),
 												(unsigned long long)
 												(*s_argument_thread).tid);
-										fflush(stdout);
 									}
 									else
 									{
-										printf("[%d] Data from thread %llu "
-												"(thread stopped)\n",
-												(int) getpid(),
+										printf("[%d] Interruption en "
+												"provenance du "
+												"thread %llu (processus "
+												"arrêté)\n", (int) getpid(),
 												(unsigned long long)
 												(*s_argument_thread).tid);
-										fflush(stdout);
 									}
-								}
 
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									fflush(stdout);
 								}
-
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).nombre_objets_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								else
 								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-								}
-							}
-						}
-
-						break;
-					}
-
-					l_element_courant = (*l_element_courant).suivant;
-				}
-			}
-		}
-
-		l_element_courant = (struct_liste_chainee *)
-				(*s_etat_processus).l_base_pile_processus;
-
-		if (drapeau_interruptions_traitees == d_faux)
-		{
-			if ((*s_argument_thread).processus_detache == d_vrai)
-			{
-				while(l_element_courant != NULL)
-				{
-					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
-							.donnee).objet)).thread).processus_detache
-							== d_faux)
-					{
-						l_element_courant = (*l_element_courant).suivant;
-						continue;
-					}
-
-					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
-							.donnee).objet)).thread).pid ==
-							(*s_argument_thread).pid)
-					{
-						while(read_atomic(s_etat_processus, (*s_argument_thread)
-								.pipe_nombre_interruptions_attente[0],
-								&pid_candidat, sizeof(pid_candidat)) ==
-								sizeof(pid_candidat))
-						{
-							if (pid_candidat == -2)
-							{
-								break;
-							}
-							else if (pid_candidat == -1)
-							{
-							}
-							else if (read_atomic(s_etat_processus,
-									(*s_argument_thread)
-									.pipe_nombre_interruptions_attente[0],
-									&pid_candidat, sizeof(pid_candidat)) ==
-									sizeof(pid_candidat))
-							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_traitement_interruption) != 0)
-								{
-									if ((*s_etat_processus).langue == 'F')
+									if (caractere == 1)
 									{
-										printf("[%d] Interruption logicielle "
-												"en provenance du processus %d"
-												" (processus arrêté)\n",
+										printf("[%d] Data from thread %llu "
+												"(processus stopped)\n",
 												(int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
+												(unsigned long long)
+												(*s_argument_thread).pid);
 									}
 									else
 									{
-										printf("[%d] Software interrupt "
-												"from process %d (processus "
-												"stopped)\n", (int) getpid(),
-												(int) (*s_argument_thread).pid);
-										fflush(stdout);
+										printf("[%d] Interrupt from thread "
+												"%llu (processus stopped)\n",
+												(int) getpid(),
+												(unsigned long long)
+												(*s_argument_thread).pid);
 									}
-								}
 
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-								}
-
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee)
-										.objet)).thread)
-										.nombre_interruptions_dans_pipe++;
-
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
+									fflush(stdout);
 								}
-
-								(*s_etat_processus)
-										.nombre_interruptions_non_affectees++;
 							}
-						}
-
-						break;
-					}
 
-					l_element_courant = (*l_element_courant).suivant;
-				}
-			}
-			else
-			{
-				while(l_element_courant != NULL)
-				{
-					if ((*(*((struct_processus_fils *) (*(*l_element_courant)
-							.donnee).objet)).thread).processus_detache
-							== d_vrai)
-					{
-						l_element_courant = (*l_element_courant).suivant;
-						continue;
-					}
-
-					if (pthread_equal((*(*((struct_processus_fils *)
-							(*(*l_element_courant).donnee).objet)).thread).tid,
-							(*s_argument_thread).tid) != 0)
-					{
-						while(read_atomic(s_etat_processus, (*s_argument_thread)
-								.pipe_nombre_interruptions_attente[0],
-								&tid_candidat, sizeof(tid_candidat)) ==
-								sizeof(tid_candidat))
-						{
-							if (tid_candidat == (pthread_t) -2)
+							if (pthread_mutex_lock(
+									&((*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).mutex)) != 0)
 							{
-								break;
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
 							}
-							else if (tid_candidat == (pthread_t) -1)
+
+							if (caractere == 1)
 							{
+								(*(*((struct_processus_fils *)
+										(*(*l_element_courant).donnee).objet))
+										.thread).nombre_objets_dans_pipe++;
 							}
-							else if (read_atomic(s_etat_processus,
-									(*s_argument_thread)
-									.pipe_nombre_interruptions_attente[0],
-									&tid_candidat, sizeof(tid_candidat)) ==
-									sizeof(tid_candidat))
+							else
 							{
-								if ((*s_etat_processus).debug == d_vrai)
-									if (((*s_etat_processus).type_debug &
-											d_traitement_interruption) != 0)
-								{
-									if ((*s_etat_processus).langue == 'F')
-									{
-										printf("[%d] Interruption logicielle "
-												"en provenance du thread %llu"
-												" (thread arrêté)\n",
-												(int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-									else
-									{
-										printf("[%d] Software interrupt "
-												"from thread %llu (thread "
-												"stopped)\n", (int) getpid(),
-												(unsigned long long)
-												(*s_argument_thread).tid);
-										fflush(stdout);
-									}
-								}
-
-								if (pthread_mutex_lock(
-										&((*(*((struct_processus_fils *)
+								(*(*((struct_processus_fils *)
 										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+										.thread)
+										.nombre_interruptions_dans_pipe++;
+
+								if (pthread_mutex_lock(&((*s_etat_processus)
+										.mutex_interruptions)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
 								}
 
-								(*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee)
-										.objet)).thread)
-										.nombre_interruptions_dans_pipe++;
+								(*s_etat_processus)
+										.nombre_interruptions_non_affectees++;
 
-								if (pthread_mutex_unlock(
-										&((*(*((struct_processus_fils *)
-										(*(*l_element_courant).donnee).objet))
-										.thread).mutex)) != 0)
+								if (pthread_mutex_unlock(&((*s_etat_processus)
+										.mutex_interruptions)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
 								}
+							}
 
-								(*s_etat_processus)
-										.nombre_interruptions_non_affectees++;
+							if (pthread_mutex_unlock(
+									&((*(*((struct_processus_fils *)
+									(*(*l_element_courant).donnee).objet))
+									.thread).mutex)) != 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
 							}
 						}
 
 						break;
 					}
-
-					l_element_courant = (*l_element_courant).suivant;
 				}
+
+				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_processus_fils =
 					d_es_processus;
@@ -1429,7 +1046,7 @@ surveillance_processus(void *argument)
 	attente.tv_nsec = GRANULARITE_us * 1000;
 
 	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
-			&((*s_etat_processus).erreur_execution_processus_fils),
+			&tampon_erreur_execution,
 			sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
 			sizeof((*s_etat_processus).erreur_execution_processus_fils))
 	{
@@ -1441,7 +1058,7 @@ surveillance_processus(void *argument)
 	attente.tv_nsec = GRANULARITE_us * 1000;
 
 	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
-			&tampon_erreur,
+			&tampon_erreur_systeme,
 			sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
 			sizeof((*s_etat_processus).erreur_systeme_processus_fils))
 	{
@@ -1449,13 +1066,11 @@ surveillance_processus(void *argument)
 		INCR_GRANULARITE(attente.tv_nsec);
 	}
 
-	(*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur;
-
 	attente.tv_sec = 0;
 	attente.tv_nsec = GRANULARITE_us * 1000;
 
 	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
-			&((*s_etat_processus).pid_erreur_processus_fils),
+			&pid_erreur,
 			sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
 			sizeof((*s_etat_processus).pid_erreur_processus_fils))
 	{
@@ -1464,18 +1079,6 @@ surveillance_processus(void *argument)
 	}
 
 	/*
-	 * Si une erreur est déclarée dans le processus fils, le message
-	 * d'erreur a déjà été affiché.
-	 */
-
-	if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
-			((*s_etat_processus).erreur_execution_processus_fils != d_ex))
-	{
-		(*s_etat_processus).erreur_processus_fils = d_vrai;
-		(*s_etat_processus).invalidation_message_erreur = d_vrai;
-	}
-
-	/*
 	 * Retrait du processus de la pile des processus
 	 */
 
@@ -1484,12 +1087,30 @@ surveillance_processus(void *argument)
 		(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
 	}
 
-	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
 	{
 		(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
 	}
 	else
 	{
+		(*s_etat_processus).erreur_execution_processus_fils =
+				tampon_erreur_execution;
+		(*s_etat_processus).erreur_systeme_processus_fils =
+				tampon_erreur_systeme;
+		(*s_etat_processus).pid_erreur_processus_fils = pid_erreur;
+
+		/*
+		 * Si une erreur est déclarée dans le processus fils, le message
+		 * d'erreur a déjà été affiché.
+		 */
+
+		if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
+				((*s_etat_processus).erreur_execution_processus_fils != d_ex))
+		{
+			(*s_etat_processus).erreur_processus_fils = d_vrai;
+			(*s_etat_processus).invalidation_message_erreur = d_vrai;
+		}
+
 		do
 		{
 			drapeau_fin = d_faux;
@@ -1660,7 +1281,7 @@ surveillance_processus(void *argument)
 				}
 
 				if (close((*s_argument_thread)
-						.pipe_nombre_objets_attente[0]) != 0)
+						.pipe_nombre_elements_attente[0]) != 0)
 				{
 					(*s_etat_processus).erreur_systeme_processus_fils =
 							d_es_processus;
@@ -1673,18 +1294,12 @@ surveillance_processus(void *argument)
 							d_es_processus;
 				}
 
-				if (close((*s_argument_thread)
-						.pipe_nombre_interruptions_attente[0]) != 0)
-				{
-					(*s_etat_processus).erreur_systeme_processus_fils =
-							d_es_processus;
-				}
-
 				drapeau_fin = d_vrai;
 			}
 			else
 			{
-				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_processus_fils =
 							d_es_processus;
@@ -1694,7 +1309,8 @@ surveillance_processus(void *argument)
 				nanosleep(&attente, NULL);
 				INCR_GRANULARITE(attente.tv_nsec);
 
-				if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+				if (pthread_mutex_lock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme_processus_fils =
 							d_es_processus;
@@ -1753,19 +1369,16 @@ surveillance_processus(void *argument)
 				{
 					(*s_etat_processus).l_base_pile_processus =
 							(*l_element_courant).suivant;
-
-					free(l_element_courant);
-
-					l_element_courant = (struct_liste_chainee *)
-							(*s_etat_processus).l_base_pile_processus;
 				}
 				else
 				{
 					(*l_element_precedent).suivant =
 							(*l_element_courant).suivant;
-					free(l_element_courant);
 				}
 
+				liberation(s_etat_processus, (*l_element_courant).donnee);
+				free(l_element_courant);
+
 				break;
 			}
 			else
@@ -1775,52 +1388,55 @@ surveillance_processus(void *argument)
 			}
 		}
 
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
-		}
-	}
-
-	if ((*s_etat_processus).debug == d_vrai)
-		if (((*s_etat_processus).type_debug &
-				d_debug_processus) != 0)
-	{
-		if ((*s_argument_thread).processus_detache == d_vrai)
+		if ((*s_etat_processus).debug == d_vrai)
+			if (((*s_etat_processus).type_debug &
+					d_debug_processus) != 0)
 		{
-			if ((*s_etat_processus).langue == 'F')
+			if ((*s_argument_thread).processus_detache == d_vrai)
 			{
-				printf("[%d] Arrêt du thread de surveillance du"
-						" processus %d\n", (int) getpid(),
-						(int) (*s_argument_thread).pid);
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("[%d] Arrêt du thread de surveillance du"
+							" processus %d\n", (int) getpid(),
+							(int) (*s_argument_thread).pid);
+				}
+				else
+				{
+					printf("[%d] Stop monitoring of process %d", (int) getpid(),
+							(int) (*s_argument_thread).pid);
+				}
 			}
 			else
 			{
-				printf("[%d] Stop monitoring of process %d", (int) getpid(),
-						(int) (*s_argument_thread).pid);
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("[%d] Arrêt du thread de surveillance du"
+							" thread %llu\n", (int) getpid(),
+							(unsigned long long) (*s_argument_thread)
+							.tid);
+				}
+				else
+				{
+					printf("[%d] Stop monitoring of thread %llu",
+							(int) getpid(),
+							(unsigned long long) (*s_argument_thread)
+							.tid);
+				}
 			}
+
+			fflush(stdout);
 		}
-		else
+
+		retrait_thread_surveillance(s_etat_processus, s_argument_thread);
+		nombre_thread_surveillance_processus--;
+
+		if (pthread_mutex_unlock(&((*s_etat_processus)
+				.mutex_pile_processus)) != 0)
 		{
-			if ((*s_etat_processus).langue == 'F')
-			{
-				printf("[%d] Arrêt du thread de surveillance du"
-						" thread %llu\n", (int) getpid(),
-						(unsigned long long) (*s_argument_thread)
-						.tid);
-			}
-			else
-			{
-				printf("[%d] Stop monitoring of thread %llu", (int) getpid(),
-						(unsigned long long) (*s_argument_thread)
-						.tid);
-			}
+			(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
 		}
-
-		fflush(stdout);
 	}
 
-	retrait_thread_surveillance(s_etat_processus, s_argument_thread);
-
 	pthread_exit(NULL);
 }
 
@@ -1846,8 +1462,8 @@ ecriture_pipe(struct_processus *s_etat_p
 
 	struct timespec					attente;
 
-	unsigned long					i;
-	unsigned long					j;
+	integer8						i;
+	integer8						j;
 
 	size_t							longueur;
 	ssize_t							longueur_ecriture;
@@ -1977,7 +1593,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_vecteur *) (*s_objet).objet))
-				.taille), sizeof(unsigned long))) != sizeof(unsigned long))
+				.taille), sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2030,7 +1646,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_vecteur *) (*s_objet).objet))
-				.taille), sizeof(unsigned long))) != sizeof(unsigned long))
+				.taille), sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2083,7 +1699,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_vecteur *) (*s_objet).objet))
-				.taille), sizeof(unsigned long))) != sizeof(unsigned long))
+				.taille), sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2136,7 +1752,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2152,7 +1768,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2211,7 +1827,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2227,7 +1843,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2286,7 +1902,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2302,7 +1918,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2496,7 +2112,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2638,7 +2254,7 @@ ecriture_pipe(struct_processus *s_etat_p
 
 		while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
 				&((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
-				sizeof(unsigned long))) != sizeof(unsigned long))
+				sizeof(integer8))) != sizeof(integer8))
 		{
 			if (longueur_ecriture == -1)
 			{
@@ -2694,8 +2310,8 @@ lecture_pipe(struct_processus *s_etat_pr
 
 	struct timespec			attente;
 
-	unsigned long			i;
-	unsigned long			j;
+	integer8				i;
+	integer8				j;
 
 	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
 	{
@@ -2782,15 +2398,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
 				(*s_objet).objet)).taille),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-				malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
-				sizeof(integer8))) == NULL)
+				malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
+				.taille) * sizeof(integer8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -2826,15 +2442,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
 				(*s_objet).objet)).taille),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-				malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
-				sizeof(real8))) == NULL)
+				malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
+				.taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -2870,15 +2486,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
 				(*s_objet).objet)).taille),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-				malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
-				sizeof(complex16))) == NULL)
+				malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
+				.taille) * sizeof(complex16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -2914,7 +2530,7 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
@@ -2925,15 +2541,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
-				sizeof(integer8 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+				.nombre_lignes) * sizeof(integer8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -2943,8 +2559,8 @@ lecture_pipe(struct_processus *s_etat_pr
 				(*s_objet).objet)).nombre_lignes; i++)
 		{
 			if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
-					malloc((*((struct_matrice *) (*s_objet).objet))
-					.nombre_colonnes * sizeof(integer8))) == NULL)
+					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+					.nombre_colonnes) * sizeof(integer8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -2982,7 +2598,7 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
@@ -2993,15 +2609,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
-				sizeof(real8 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+				.nombre_lignes) * sizeof(real8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -3011,8 +2627,8 @@ lecture_pipe(struct_processus *s_etat_pr
 				(*s_objet).objet)).nombre_lignes; i++)
 		{
 			if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
-					malloc((*((struct_matrice *) (*s_objet).objet))
-					.nombre_colonnes * sizeof(real8))) == NULL)
+					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -3050,7 +2666,7 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_lignes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
@@ -3061,15 +2677,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
 				(*s_objet).objet)).nombre_colonnes),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
-				sizeof(complex16 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+				.nombre_lignes) * sizeof(complex16 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -3079,8 +2695,8 @@ lecture_pipe(struct_processus *s_etat_pr
 				(*s_objet).objet)).nombre_lignes; i++)
 		{
 			if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
-					malloc((*((struct_matrice *) (*s_objet).objet))
-					.nombre_colonnes * sizeof(complex16))) == NULL)
+					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
+					.nombre_colonnes) * sizeof(complex16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(NULL);
@@ -3208,8 +2824,8 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe,
 				&((*((struct_fonction *) (*s_objet).objet))
-				.nombre_arguments), sizeof(unsigned long)) !=
-				sizeof(unsigned long))
+				.nombre_arguments), sizeof(integer8)) !=
+				sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
@@ -3329,15 +2945,15 @@ lecture_pipe(struct_processus *s_etat_pr
 
 		while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
 				(*s_objet).objet)).nombre_elements),
-				sizeof(unsigned long)) != sizeof(unsigned long))
+				sizeof(integer8)) != sizeof(integer8))
 		{
 			nanosleep(&attente, NULL);
 			INCR_GRANULARITE(attente.tv_nsec);
 		}
 
 		if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
-				(*((struct_tableau *) (*s_objet).objet)).nombre_elements *
-				sizeof(struct_objet *))) == NULL)
+				((size_t) (*((struct_tableau *) (*s_objet).objet))
+				.nombre_elements) * sizeof(struct_objet *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -3379,40 +2995,28 @@ lecture_pipe(struct_processus *s_etat_pr
 ================================================================================
 */
 
-extern inline void
+void
 scrutation_injection(struct_processus *s_etat_processus)
 {
-	fd_set							ensemble_descripteurs;
+	logical1						drapeau_erreur;
+	logical1						registre_arret_si_exception;
 
-#	ifndef OpenBSD
-		struct timespec				timeout;
-#	else
-		struct timeval				timeout;
-#	endif
+	struct pollfd					fds;
 
 	unsigned char					tampon;
+	unsigned char					tampon_profilage[20];
 
 	// Si on est dans le processus père, il n'y a rien à surveiller.
 
-	if ((*s_etat_processus).var_volatile_processus_pere == 0)
+	scrutation_interruptions(s_etat_processus);
+
+	if ((*s_etat_processus).var_volatile_processus_racine == 0)
 	{
-		FD_ZERO(&ensemble_descripteurs);
-		FD_SET((*s_etat_processus).pipe_nombre_injections,
-				&ensemble_descripteurs);
-
-#		ifndef OpenBSD
-		timeout.tv_sec = 0;
-		timeout.tv_nsec = 0;
-
-		if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
-				&ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
-#		else
-		timeout.tv_sec = 0;
-		timeout.tv_usec = 0;
-
-		if (select((*s_etat_processus).pipe_nombre_injections + 1,
-				&ensemble_descripteurs, NULL, NULL, &timeout) > 0)
-#		endif
+		fds.fd = (*s_etat_processus).pipe_nombre_injections;
+		fds.events = POLLIN;
+		fds.revents = 0;
+
+		if (poll(&fds, 1, 0) > 0)
 		{
 			if (read_atomic(s_etat_processus,
 					(*s_etat_processus).pipe_nombre_injections,
@@ -3437,6 +3041,139 @@ scrutation_injection(struct_processus *s
 				}
 			}
 		}
+
+		/*
+		 * Traitement de l'interruption d'injection
+		 */
+
+		if (((*s_etat_processus).nombre_objets_injectes != 0) &&
+				((*s_etat_processus).traitement_at_poke == 'N'))
+		{
+			if ((*s_etat_processus).at_poke != NULL)
+			{
+				registre_arret_si_exception =
+						(*s_etat_processus).arret_si_exception;
+				(*s_etat_processus).arret_si_exception = d_vrai;
+
+				if ((*s_etat_processus).debug == d_vrai)
+					if (((*s_etat_processus).type_debug &
+							d_traitement_interruption) != 0)
+				{
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("[%d] Traitement de l'interruption "
+								"d'injection\n", (int) getpid());
+					}
+					else
+					{
+						printf("[%d] Start injection interrupt\n",
+								(int) getpid());
+					}
+
+					fflush(stdout);
+				}
+
+				if ((*s_etat_processus).profilage == d_vrai)
+				{
+					sprintf(tampon_profilage, "Injection interrupt");
+					profilage(s_etat_processus, tampon_profilage);
+
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						return;
+					}
+				}
+
+				(*s_etat_processus).traitement_at_poke = 'Y';
+				drapeau_erreur = evaluation(s_etat_processus,
+						(*s_etat_processus).at_poke, 'E');
+				(*s_etat_processus).traitement_at_poke = 'N';
+
+				if ((*s_etat_processus).profilage == d_vrai)
+				{
+					profilage(s_etat_processus, NULL);
+				}
+
+				if (drapeau_erreur == d_absence_erreur)
+				{
+					(*s_etat_processus).arret_si_exception =
+							registre_arret_si_exception;
+				}
+				else
+				{
+					if ((((*s_etat_processus).erreur_execution != d_ex) ||
+							((*s_etat_processus).exception != d_ep) ||
+							((*s_etat_processus).erreur_systeme != d_es)) &&
+							((*s_etat_processus).core == d_vrai) &&
+							((*s_etat_processus)
+							.var_volatile_traitement_sigint == 0))
+					{
+						printf("\n");
+						
+						if ((*s_etat_processus).langue == 'F')
+						{
+							printf("+++Information : "
+									"Génération du fichier rpl-core "
+									"[%d]\n", (int) getpid());
+						}
+						else
+						{
+							printf("+++Information : "
+									"Writing rpl-core file [%d]\n",
+									(int) getpid());
+						}
+
+						rplcore(s_etat_processus);
+
+						if ((*s_etat_processus).langue == 'F')
+						{
+							printf("+++Information : "
+									"Processus tracé [%d]\n",
+									(int) getpid());
+						}
+						else
+						{
+							printf("+++Information : Done [%d]\n",
+									(int) getpid());
+						}
+
+						printf("\n");
+						fflush(stdout);
+					}
+
+				}
+
+				if ((*s_etat_processus).debug == d_vrai)
+					if (((*s_etat_processus).type_debug &
+							d_traitement_interruption) != 0)
+				{
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("[%d] Fin de l'interruption d'injection\n",
+								(int) getpid());
+					}
+					else
+					{
+						printf("[%d] Stop injection interrupt\n",
+								(int) getpid());
+					}
+
+					fflush(stdout);
+				}
+
+				if ((drapeau_erreur == d_erreur) &&
+						((*s_etat_processus).erreur_execution == d_ex))
+				{
+					if (((*s_etat_processus).erreur_execution == d_ex) &&
+							((*s_etat_processus).erreur_systeme == d_es))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_evaluation;
+					}
+				}
+			}
+		}
+
 	}
 
 	return;
@@ -3455,7 +3192,8 @@ scrutation_injection(struct_processus *s
 ================================================================================
 */
 
-inline int test_arret(struct_processus *s_etat_processus)
+int
+test_arret(struct_processus *s_etat_processus)
 {
 	return((int) (*s_etat_processus).var_volatile_requete_arret);
 }