--- rpl/src/gestion_objets.c	2011/07/25 07:44:54	1.59
+++ rpl/src/gestion_objets.c	2016/03/15 16:31:40	1.128
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.2
-  Copyright (C) 1989-2011 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.
 
@@ -112,9 +112,11 @@ initialisation_allocateur(struct_process
 	(*s_etat_processus).pointeur_maillons = 0;
 
 	(*s_etat_processus).pointeur_variables_noeud = 0;
+	(*s_etat_processus).pointeur_variables_partagees_noeud = 0;
 	(*s_etat_processus).pointeur_variables_feuille = 0;
 	(*s_etat_processus).pointeur_variables_variable = 0;
 	(*s_etat_processus).pointeur_variables_tableau_noeuds = 0;
+	(*s_etat_processus).pointeur_variables_tableau_noeuds_partages = 0;
 
 	return;
 }
@@ -150,12 +152,17 @@ liberation_allocateur(struct_processus *
 
 	for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud;
 			free((*s_etat_processus).variables_noeud[i++]));
+	for(i = 0; i < (*s_etat_processus).pointeur_variables_partagees_noeud;
+			free((*s_etat_processus).variables_partagees_noeud[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille;
 			free((*s_etat_processus).variables_feuille[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_variables_variable;
 			free((*s_etat_processus).variables_variable[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds;
 			free((*s_etat_processus).variables_tableau_noeuds[i++]));
+	for(i = 0; i < (*s_etat_processus)
+			.pointeur_variables_tableau_noeuds_partages;
+			free((*s_etat_processus).variables_tableau_noeuds_partages[i++]));
 
 	{
 		struct_liste_chainee		*l_element_courant;
@@ -238,6 +245,7 @@ allocation_maillon(struct_processus *s_e
 	{
 		if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 	}
@@ -311,6 +319,7 @@ allocation(struct_processus *s_etat_proc
 
 		if ((s_objet = malloc(sizeof(struct_objet))) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
@@ -346,8 +355,10 @@ allocation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL)
+				if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -373,6 +384,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -399,6 +412,8 @@ allocation(struct_processus *s_etat_proc
 				if (((*s_objet).objet = malloc(sizeof(struct_complexe16)))
 						== NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -411,6 +426,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -430,6 +446,8 @@ allocation(struct_processus *s_etat_proc
 				if (((*s_objet).objet = malloc(sizeof(struct_fonction)))
 						== NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -453,6 +471,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -478,6 +498,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -501,6 +523,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -524,6 +548,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -540,10 +566,12 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
 
+			(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self();
 			break;
 		}
 
@@ -558,6 +586,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -577,6 +607,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -595,6 +626,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -613,6 +646,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -625,6 +659,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -636,6 +671,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -648,6 +684,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -666,6 +703,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -687,6 +726,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -709,6 +750,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -731,6 +774,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -772,13 +817,10 @@ liberation(struct_processus *s_etat_proc
 {
 	logical1							drapeau;
 
-	sigset_t							oldset;
-	sigset_t							set;
-
 	struct_liste_chainee				*l_element_courant;
 	struct_liste_chainee				*l_element_suivant;
 
-	unsigned long						i;
+	integer8							i;
 
 	if (s_objet == NULL)
 	{
@@ -817,7 +859,7 @@ liberation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				free((unsigned long *) ((*s_objet).objet));
+				free((*s_objet).objet);
 			}
 
 			break;
@@ -884,7 +926,7 @@ liberation(struct_processus *s_etat_proc
 				return;
 			}
 
-			free((unsigned char *) ((*s_objet).objet));
+			free((unsigned char *) (*s_objet).objet);
 			break;
 		}
 
@@ -1106,6 +1148,28 @@ liberation(struct_processus *s_etat_proc
 				return;
 			}
 
+			if (pthread_mutex_trylock(&((*((struct_mutex *)
+					(*s_objet).objet)).mutex)) == 0)
+			{
+				// On a pu verrouiller le mutex. Il faut donc spécifier le tid.
+				(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self();
+			}
+
+			if (pthread_equal(pthread_self(),
+					(*((struct_mutex *) (*s_objet).objet)).tid) != 0)
+			{
+				pthread_mutex_unlock(&((*((struct_mutex *)
+						(*s_objet).objet)).mutex));
+			}
+			else
+			{
+				(*s_etat_processus).erreur_systeme =
+						d_es_mutex_acquis_autre_thread;
+				return;
+			}
+
+			pthread_mutex_destroy(&((*((struct_mutex *)
+					(*s_objet).objet)).mutex));
 			free((struct_mutex *) (*s_objet).objet);
 			break;
 		}
@@ -1144,15 +1208,9 @@ liberation(struct_processus *s_etat_proc
 
 		case PRC :
 		{
-			sigfillset(&set);
-			pthread_sigmask(SIG_BLOCK, &set, &oldset);
-
 			if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
-				pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-				sigpending(&set);
-
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
@@ -1180,16 +1238,10 @@ liberation(struct_processus *s_etat_proc
 			if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
-				pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-				sigpending(&set);
-
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
 
-			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-			sigpending(&set);
-
 			if (drapeau == d_vrai)
 			{
 				pthread_mutex_destroy(&((*(*((struct_processus_fils *)
@@ -1342,7 +1394,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 *)
@@ -1527,9 +1579,6 @@ struct_objet *
 copie_objet(struct_processus *s_etat_processus,
 		struct_objet *s_objet, unsigned char type)
 {
-	sigset_t					oldset;
-	sigset_t					set;
-
 	struct_liste_chainee		*l_element_base;
 	struct_liste_chainee		*l_element_courant;
 	struct_liste_chainee		*l_element_courant_ecriture;
@@ -1540,8 +1589,8 @@ copie_objet(struct_processus *s_etat_pro
 	struct_objet				*s_nouvel_objet;
 	struct_objet				*s_objet_tampon;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
 	{
@@ -1592,8 +1641,8 @@ copie_objet(struct_processus *s_etat_pro
 				return(NULL);
 			}
 
-			(*((unsigned long *) ((*s_nouvel_objet).objet))) =
-					(*((unsigned long *) ((*s_objet).objet)));
+			(*((integer8 *) ((*s_nouvel_objet).objet))) =
+					(*((integer8 *) ((*s_objet).objet)));
 			break;
 		}
 
@@ -1658,7 +1707,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else // type == 'P'
@@ -1710,7 +1759,7 @@ copie_objet(struct_processus *s_etat_pro
 				return(NULL);
 			}
 
-			(*s_nouvel_objet).objet = (void *) ((unsigned char *)
+			(*s_nouvel_objet).objet = ((unsigned char *)
 					malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
 					* sizeof(unsigned char)));
 
@@ -1804,7 +1853,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else // type == 'P'
@@ -2011,7 +2060,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else
@@ -2046,9 +2095,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
-					(void **) ((integer8 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(integer8 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes)) * sizeof(integer8 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2070,9 +2118,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((integer8 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((integer8 *) malloc(
+						((integer8 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(integer8)))) == NULL)
+						.nombre_colonnes)) * sizeof(integer8)))) == NULL)
 				{
 					for(j = 0; j < i; j++)
 					{
@@ -2113,9 +2161,9 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
-					(void **) ((struct_complexe16 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(struct_complexe16 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes))
+					* sizeof(struct_complexe16 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2137,9 +2185,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((struct_complexe16 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((struct_complexe16 *) malloc(
+						((struct_complexe16 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(struct_complexe16))))
+						.nombre_colonnes)) * sizeof(struct_complexe16))))
 						== NULL)
 				{
 					for(j = 0; j < i; j++)
@@ -2180,9 +2228,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = 
-					(void **) ((real8 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(real8 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes)) * sizeof(real8 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2204,9 +2251,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((real8 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((real8 *) malloc(
+						((real8 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(real8)))) == NULL)
+						.nombre_colonnes)) * sizeof(real8)))) == NULL)
 				{
 					for(j = 0; j < i; j++)
 					{
@@ -2234,20 +2281,9 @@ copie_objet(struct_processus *s_etat_pro
 
 		case MTX :
 		{
-			if (type != 'O')
-			{
-				incrementation_atomique(s_objet);
-				return(s_objet);
-			}
-
-			if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
-			{
-				return(NULL);
-			}
-
-			(*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex =
-					(*((struct_mutex *) ((*s_objet).objet))).mutex;
-			break;
+			// La duplication d'un mutex renvoie le même objet.
+			incrementation_atomique(s_objet);
+			return(s_objet);
 		}
 
 		case NOM :
@@ -2289,26 +2325,25 @@ copie_objet(struct_processus *s_etat_pro
 				return(s_objet);
 			}
 
+			// Un objet de type NON est un objet encapsulé dans une
+			// structure de type struct_objet. Elle peut très bien contenir
+			// une donnée, mais c'est à l'utilisateur de la libérer
+			// explicitement avec un free().
+
 			if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)
 			{
 				return(NULL);
 			}
 
-			(*s_nouvel_objet).objet = NULL;
+			(*s_nouvel_objet).objet = (*s_objet).objet;
 			break;
 		}
 
 		case PRC :
 		{
-			sigfillset(&set);
-			pthread_sigmask(SIG_BLOCK, &set, &oldset);
-
 			if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
-				pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-				sigpending(&set);
-
 				return(NULL);
 			}
 
@@ -2318,15 +2353,9 @@ copie_objet(struct_processus *s_etat_pro
 			if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
 					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
-				pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-				sigpending(&set);
-
 				return(NULL);
 			}
 
-			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-			sigpending(&set);
-
 			if (type != 'O')
 			{
 				incrementation_atomique(s_objet);
@@ -2405,6 +2434,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 *)
@@ -2514,6 +2555,8 @@ copie_objet(struct_processus *s_etat_pro
 				return(NULL);
 			}
 
+			(*((struct_semaphore *) (*s_nouvel_objet).objet)).semaphore =
+					(*((struct_semaphore *) (*s_objet).objet)).semaphore;
 			strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom,
 					(*((struct_semaphore *) (*s_objet).objet)).nom);
 			break;
@@ -2592,8 +2635,9 @@ copie_objet(struct_processus *s_etat_pro
 						(*s_objet).objet)).nombre_elements;
 
 				if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
-						malloc((*((struct_tableau *) (*s_objet).objet))
-						.nombre_elements * sizeof(struct_objet *))) == NULL)
+						malloc(((size_t) (*((struct_tableau *)
+						(*s_objet).objet)).nombre_elements)
+						* sizeof(struct_objet *))) == NULL)
 				{
 					return(NULL);
 				}
@@ -2653,8 +2697,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((integer8 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((integer8 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(integer8)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2696,8 +2740,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((struct_complexe16 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((struct_complexe16 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(struct_complexe16)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2739,8 +2783,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((real8 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((real8 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(real8)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2803,25 +2847,46 @@ copie_etat_processus(struct_processus *s
 
 	struct_processus				*s_nouvel_etat_processus;
 
-	unsigned long					i;
+	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,
@@ -2831,16 +2896,14 @@ copie_etat_processus(struct_processus *s
 	 * n'ont aucune raison de changer.
 	 */
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
-#	else
-	if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork))
-			== SEM_FAILED)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(NULL);
-	}
-#	endif
+	(*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
+	// de sem_init().
+
+	initialisation_contexte_cas(s_etat_processus);
 
 	(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
 	(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
@@ -2901,9 +2964,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);
@@ -2917,7 +2980,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);
@@ -2937,7 +3001,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);
@@ -2958,7 +3023,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);
@@ -2978,11 +3044,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);
@@ -3002,11 +3070,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);
@@ -3026,11 +3096,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);
@@ -3050,11 +3121,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);
@@ -3074,11 +3146,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);
@@ -3098,11 +3171,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);
@@ -3124,6 +3198,7 @@ copie_etat_processus(struct_processus *s
 	 * Copie de la table des variables
 	 */
 
+	(*s_nouvel_etat_processus).l_liste_variables_statiques = NULL;
 	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
 
 	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
@@ -3131,65 +3206,10 @@ copie_etat_processus(struct_processus *s
 		return(NULL);
 	}
 
-	/*
-	 * Copie de la table des variables statiques
-	 */
-
-	if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
-			malloc((*s_etat_processus).nombre_variables_statiques_allouees *
-			sizeof(struct_variable_statique))) == NULL)
-	{
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return(NULL);
-		}
-
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(NULL);
-	}
-
-	for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
-	{
-		if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =
-				malloc((strlen((*s_etat_processus).s_liste_variables_statiques
-				[i].nom) + 1) * sizeof(unsigned char))) == NULL)
-		{
-			if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return(NULL);
-			}
-
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(NULL);
-		}
-
-		strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
-				(*s_etat_processus).s_liste_variables_statiques[i].nom);
-
-		(*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
-				(*s_etat_processus).s_liste_variables_statiques[i].origine;
-		(*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
-				(*s_etat_processus).s_liste_variables_statiques[i].niveau;
-		(*s_nouvel_etat_processus).s_liste_variables_statiques[i]
-				.variable_statique = (*s_etat_processus)
-				.s_liste_variables_statiques[i].variable_statique;
-
-		if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
-				copie_objet(s_etat_processus, (*s_etat_processus)
-				.s_liste_variables_statiques[i].objet, 'P')) == NULL)
-		{
-			if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 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).l_liste_variables_partagees) =
+			(*(*s_etat_processus).l_liste_variables_partagees);
+	(*(*s_nouvel_etat_processus).s_arbre_variables_partagees) =
+			(*(*s_etat_processus).s_arbre_variables_partagees);
 
 	/*
 	 * Copie de la pile opérationnelle
@@ -3201,9 +3221,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);
@@ -3216,7 +3238,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);
@@ -3252,7 +3275,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);
@@ -3274,7 +3298,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);
@@ -3298,14 +3323,19 @@ copie_etat_processus(struct_processus *s
 	 * Copie des différents contextes
 	 */
 
+	(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
+	(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;
+
 	(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
 	l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
 
 	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);
@@ -3318,7 +3348,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);
@@ -3349,9 +3380,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);
@@ -3364,7 +3397,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);
@@ -3400,9 +3434,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);
@@ -3415,7 +3451,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);
@@ -3446,9 +3483,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);
@@ -3458,8 +3497,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);
@@ -3474,10 +3513,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);
@@ -3508,7 +3549,8 @@ copie_etat_processus(struct_processus *s
 	if ((*s_etat_processus).nombre_instructions_externes != 0)
 	{
 		if (((*s_nouvel_etat_processus).s_instructions_externes =
-				malloc((*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;
@@ -3518,7 +3560,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;
@@ -3529,9 +3572,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);
@@ -3553,16 +3596,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);
 
-	if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+	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_pile_processus)) != 0)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return(NULL);
@@ -3962,22 +4018,10 @@ debug_fork()
 	pthread_mutex_lock(&mutex_allocation);
 	pid = fork();
 
-#	ifdef OS2
 	if (pid == 0)
 	{
-		sem_init(&semaphore_liste_threads, 0, 1);
-		sem_init(&semaphore_gestionnaires_signaux, 0, 0);
-		sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
-		sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
-	}
-#	endif
-
-	if (pid == 0)
-	{
-#		ifdef _BROKEN_SIGINFO
-		liberation_fifos_signaux(s_etat_processus);
-		creation_fifos_signaux(s_etat_processus);
-#		endif
+		liberation_queue_signaux(s_etat_processus);
+		creation_queue_signaux(s_etat_processus);
 
 		pthread_mutex_destroy(&mutex_allocation);
 		debug_memoire_initialisation();