--- rpl/src/gestion_objets.c	2013/03/21 12:07:38	1.98
+++ rpl/src/gestion_objets.c	2018/05/30 09:27:32	1.138
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.29
+  Copyright (C) 1989-2018 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -343,6 +343,8 @@ allocation(struct_processus *s_etat_proc
 	}
 
 	(*s_objet).type = type;
+	(*s_objet).extension_type = 0;
+	(*s_objet).descripteur_bibliotheque = NULL;
 
 	switch(type)
 	{
@@ -434,6 +436,12 @@ allocation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT :
+		{
+			// Aucune allocation
+			break;
+		}
+
 		case FCT :
 		{
 			if ((*s_etat_processus).pointeur_fct > 0)
@@ -821,6 +829,8 @@ liberation(struct_processus *s_etat_proc
 	struct_liste_chainee				*l_element_suivant;
 
 	integer8							i;
+	integer8							(*__type_drop)(struct_processus *,
+												void **);
 
 	if (s_objet == NULL)
 	{
@@ -926,7 +936,7 @@ liberation(struct_processus *s_etat_proc
 				return;
 			}
 
-			free((unsigned char *) ((*s_objet).objet));
+			free((unsigned char *) (*s_objet).objet);
 			break;
 		}
 
@@ -1394,7 +1404,7 @@ liberation(struct_processus *s_etat_proc
 							.nombre_occurrences <= 1,
 							pthread_mutex_unlock(&((*s_objet).mutex)),
 							printf("(*((*((struct_tableau *) (*s_objet).objet))"
-							".element[%lu])).nombre_occurrences=%ld\n", i,
+							".element[%lld])).nombre_occurrences=%ld\n", i,
 							(*((*((struct_tableau *) (*s_objet).objet))
 							.elements[i])).nombre_occurrences));
 					liberation(s_etat_processus, (*((struct_tableau *)
@@ -1493,6 +1503,57 @@ liberation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT:
+		{
+			if (decrementation_atomique(s_objet) > 0)
+			{
+				return;
+			}
+
+			// Appel de la fonction de liberation associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_drop = dlsym((*s_objet)
+							.descripteur_bibliotheque, "__type_drop")) == NULL)
+					{
+						// La fonction de libération n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_drop;
+					}
+					else
+					{
+						if (__type_drop(s_etat_processus, (void **) &s_objet)
+								== 0)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_type_externe_drop;
+						}
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_drop;
+			}
+
+			break;
+		}
+
 		default :
 		{
 			if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
@@ -1591,6 +1652,7 @@ copie_objet(struct_processus *s_etat_pro
 
 	integer8					i;
 	integer8					j;
+	integer8					(*__type_dup)(struct_processus *, void **);
 
 	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
 	{
@@ -2434,6 +2496,18 @@ copie_objet(struct_processus *s_etat_pro
 					(*((struct_socket *) ((*s_objet).objet))).pid;
 			(*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
 					(*((struct_socket *) ((*s_objet).objet))).tid;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).options =
+					(*((struct_socket *) ((*s_objet).objet))).options;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).priorite =
+					(*((struct_socket *) ((*s_objet).objet))).priorite;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_reception =
+					(*((struct_socket *) ((*s_objet).objet))).buffer_reception;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_emission =
+					(*((struct_socket *) ((*s_objet).objet))).buffer_emission;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_reception =
+					(*((struct_socket *) ((*s_objet).objet))).timeout_reception;
+			(*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_emission =
+					(*((struct_socket *) ((*s_objet).objet))).timeout_emission;
 
 			if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
 					copie_objet(s_etat_processus, (*((struct_socket *)
@@ -2800,6 +2874,59 @@ copie_objet(struct_processus *s_etat_pro
 			break;
 		}
 
+		case EXT:
+		{
+			if (type != 'O')
+			{
+				incrementation_atomique(s_objet);
+				return(s_objet);
+			}
+
+			// Appel de la fonction de duplication associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_dup = dlsym((*s_objet).descripteur_bibliotheque,
+							"__type_dup")) == NULL)
+					{
+						// La fonction de duplication n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_dup;
+						return(NULL);
+					}
+
+					s_nouvel_objet = s_objet;
+
+					if (__type_dup(s_etat_processus, (void **) &s_nouvel_objet)
+							== 0)
+					{
+						return(NULL);
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_dup;
+				return(NULL);
+			}
+
+			break;
+		}
+
 		default :
 		{
 			return(NULL);
@@ -2837,23 +2964,44 @@ copie_etat_processus(struct_processus *s
 
 	integer8						i;
 
-	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 = d_es_processus;
 		return(NULL);
 	}
 
-	if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)
+	if ((s_nouvel_etat_processus = sys_malloc(sizeof(struct_processus)))
+			== NULL)
 	{
+		if (pthread_mutex_unlock(&((*s_etat_processus)
+				.mutex_pile_processus)) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return(NULL);
+		}
+
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return(NULL);
 	}
 
 	(*s_nouvel_etat_processus) = (*s_etat_processus);
 
-	// On réinitialise l'allocateur.
+	// On réinitialise les allocateurs.
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation_buffer),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
 
 	initialisation_allocateur(s_nouvel_etat_processus);
+	initialisation_allocateur_buffer(s_nouvel_etat_processus);
 
 	/*
 	 * (*s_etat_processus).definition_chainee,
@@ -2863,9 +3011,8 @@ copie_etat_processus(struct_processus *s
 	 * n'ont aucune raison de changer.
 	 */
 
-	pthread_mutexattr_init(&attributs_mutex);
-	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
 	(*s_nouvel_etat_processus).sections_critiques = 0;
+	(*s_nouvel_etat_processus).initialisation_scheduler = d_faux;
 
 	// Les sémaphores sont initialisés dans le nouveau thread. Il
 	// s'agit d'une limitation de l'implantation de l'émulation
@@ -2932,9 +3079,9 @@ copie_etat_processus(struct_processus *s
 
 	// Copie de la localisation
 
-	if (((*s_nouvel_etat_processus).localisation = malloc((strlen(
-			(*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))
-			== NULL)
+	if (((*s_nouvel_etat_processus).localisation = rpl_malloc(
+			s_nouvel_etat_processus, (strlen((*s_etat_processus).localisation)
+			+ 1) * sizeof(unsigned char))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return(NULL);
@@ -2948,7 +3095,8 @@ copie_etat_processus(struct_processus *s
 		if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
 				(*s_etat_processus).indep, 'P')) == NULL)
 		{
-			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(NULL);
@@ -2968,7 +3116,8 @@ copie_etat_processus(struct_processus *s
 		if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus, 
 				(*s_etat_processus).depend, 'P')) == NULL)
 		{
-			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(NULL);
@@ -2989,7 +3138,8 @@ copie_etat_processus(struct_processus *s
 				copie_objet(s_etat_processus, (*s_etat_processus)
 				.parametres_courbes_de_niveau, 'P')) == NULL)
 		{
-			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(NULL);
@@ -3009,11 +3159,13 @@ copie_etat_processus(struct_processus *s
 	if (((*s_etat_processus).instruction_courante != NULL) &&
 			(*s_etat_processus).evaluation_expression_compilee == 'N')
 	{
-		if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(
+		if (((*s_nouvel_etat_processus).instruction_courante = rpl_malloc(
+				s_nouvel_etat_processus, (strlen(
 				(*s_etat_processus).instruction_courante) + 1) *
 				sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3033,11 +3185,13 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_etat_processus).label_x != NULL)
 	{
-		if (((*s_nouvel_etat_processus).label_x = malloc((strlen(
+		if (((*s_nouvel_etat_processus).label_x = rpl_malloc(
+				s_nouvel_etat_processus, (strlen(
 				(*s_etat_processus).label_x) + 1) *
 				sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3057,11 +3211,12 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_etat_processus).label_y != NULL)
 	{
-		if (((*s_nouvel_etat_processus).label_y = malloc((strlen(
-				(*s_etat_processus).label_y) + 1) *
-				sizeof(unsigned char))) == NULL)
+		if (((*s_nouvel_etat_processus).label_y = rpl_malloc(
+				s_nouvel_etat_processus, (strlen((*s_etat_processus).label_y)
+				+ 1) * sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3081,11 +3236,12 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_etat_processus).label_z != NULL)
 	{
-		if (((*s_nouvel_etat_processus).label_z = malloc((strlen(
-				(*s_etat_processus).label_z) + 1) *
-				sizeof(unsigned char))) == NULL)
+		if (((*s_nouvel_etat_processus).label_z = rpl_malloc(
+				s_nouvel_etat_processus, (strlen((*s_etat_processus).label_z)
+				+ 1) * sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3105,11 +3261,12 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_etat_processus).titre != NULL)
 	{
-		if (((*s_nouvel_etat_processus).titre = malloc((strlen(
-				(*s_etat_processus).titre) + 1) *
-				sizeof(unsigned char))) == NULL)
+		if (((*s_nouvel_etat_processus).titre = rpl_malloc(
+				s_nouvel_etat_processus, (strlen((*s_etat_processus).titre) + 1)
+				* sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3129,11 +3286,12 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_etat_processus).legende != NULL)
 	{
-		if (((*s_nouvel_etat_processus).legende = malloc((strlen(
-				(*s_etat_processus).legende) + 1) *
-				sizeof(unsigned char))) == NULL)
+		if (((*s_nouvel_etat_processus).legende = rpl_malloc(
+				s_nouvel_etat_processus, (strlen((*s_etat_processus).legende)
+				+ 1) * sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3178,9 +3336,11 @@ copie_etat_processus(struct_processus *s
 
 	while(l_element_lecture != NULL)
 	{
-		if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
+		if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_liste_chainee))) == NULL)
 		{
-			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(NULL);
@@ -3193,7 +3353,8 @@ copie_etat_processus(struct_processus *s
 		if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
 				(*l_element_lecture).donnee, 'P')) == NULL)
 		{
-			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(NULL);
@@ -3229,7 +3390,8 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
 	{
-		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(NULL);
@@ -3251,7 +3413,8 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
 	{
-		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(NULL);
@@ -3283,9 +3446,11 @@ copie_etat_processus(struct_processus *s
 
 	while(l_element_lecture != NULL)
 	{
-		if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
+		if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_liste_chainee))) == NULL)
 		{
-			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(NULL);
@@ -3298,7 +3463,8 @@ copie_etat_processus(struct_processus *s
 		if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
 				(*l_element_lecture).donnee, 'P')) == NULL)
 		{
-			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(NULL);
@@ -3329,9 +3495,11 @@ copie_etat_processus(struct_processus *s
 
 	while(l_element_lecture != NULL)
 	{
-		if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
+		if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_liste_chainee))) == NULL)
 		{
-			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(NULL);
@@ -3344,7 +3512,8 @@ copie_etat_processus(struct_processus *s
 		if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
 				(*l_element_lecture).donnee, 'P')) == NULL)
 		{
-			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(NULL);
@@ -3380,9 +3549,11 @@ copie_etat_processus(struct_processus *s
 
 	while(l_element_lecture != NULL)
 	{
-		if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
+		if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_liste_chainee))) == NULL)
 		{
-			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(NULL);
@@ -3395,7 +3566,8 @@ copie_etat_processus(struct_processus *s
 		if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
 				(*l_element_lecture).donnee, 'P')) == NULL)
 		{
-			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(NULL);
@@ -3426,9 +3598,11 @@ copie_etat_processus(struct_processus *s
 
 	while(l_element_lecture != NULL)
 	{
-		if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
+		if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_liste_chainee))) == NULL)
 		{
-			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(NULL);
@@ -3438,8 +3612,8 @@ copie_etat_processus(struct_processus *s
 			return(NULL);
 		}
 
-		if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))
-				== NULL)
+		if (((*l_element_suivant).donnee = rpl_malloc(s_nouvel_etat_processus,
+				sizeof(struct_bibliotheque))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
@@ -3454,10 +3628,12 @@ copie_etat_processus(struct_processus *s
 				= (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
 
 		if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
-				malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)
+				rpl_malloc(s_nouvel_etat_processus,
+				(strlen((*((struct_bibliotheque *) (*l_element_lecture)
 				.donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
 		{
-			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(NULL);
@@ -3488,8 +3664,8 @@ copie_etat_processus(struct_processus *s
 	if ((*s_etat_processus).nombre_instructions_externes != 0)
 	{
 		if (((*s_nouvel_etat_processus).s_instructions_externes =
-				malloc(((size_t) (*s_etat_processus)
-				.nombre_instructions_externes) *
+				rpl_malloc(s_nouvel_etat_processus, ((size_t)
+				(*s_etat_processus).nombre_instructions_externes) *
 				sizeof(struct_instruction_externe))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -3499,7 +3675,8 @@ copie_etat_processus(struct_processus *s
 		for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
 		{
 			if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
-					malloc((strlen((*s_etat_processus).s_instructions_externes
+					rpl_malloc(s_nouvel_etat_processus,
+					(strlen((*s_etat_processus).s_instructions_externes
 					[i].nom) + 1) * sizeof(unsigned char))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -3510,9 +3687,9 @@ copie_etat_processus(struct_processus *s
 					(*s_etat_processus).s_instructions_externes[i].nom);
 
 			if (((*s_nouvel_etat_processus).s_instructions_externes[i]
-					.nom_bibliotheque = malloc((strlen((*s_etat_processus)
-					.s_instructions_externes[i].nom_bibliotheque) + 1) *
-					sizeof(unsigned char))) == NULL)
+					.nom_bibliotheque = rpl_malloc(s_nouvel_etat_processus,
+					(strlen((*s_etat_processus).s_instructions_externes[i]
+					.nom_bibliotheque) + 1) * sizeof(unsigned char))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return(NULL);
@@ -3534,16 +3711,29 @@ copie_etat_processus(struct_processus *s
 
 	pthread_mutexattr_init(&attributs_mutex);
 	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
-	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);
+	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_pile_processus),
+			&attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
 	pthread_mutexattr_init(&attributs_mutex);
 	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
-	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),
+	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_interruptions),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_signaux),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_nouvel_etat_processus).protection_liste_mutexes),
 			&attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
-	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(NULL);