--- rpl/src/gestion_objets.c	2010/05/19 09:22:34	1.18
+++ rpl/src/gestion_objets.c	2013/09/06 10:30:51	1.107
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.15
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.16
+  Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -57,7 +57,7 @@ decrementation_atomique(struct_objet *s_
 	return((*s_objet).nombre_occurrences);
 }
 
-inline void
+void
 initialisation_objet(struct_objet *s_objet)
 {
 	pthread_mutexattr_t		attributs_mutex;
@@ -111,6 +111,13 @@ initialisation_allocateur(struct_process
 	(*s_etat_processus).pointeur_vec = 0;
 	(*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;
 }
 
@@ -143,6 +150,20 @@ liberation_allocateur(struct_processus *
 	for(i = 0; i < (*s_etat_processus).pointeur_maillons;
 			free((*s_etat_processus).maillons[i++]));
 
+	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;
 		struct_liste_chainee		*l_element_suivant;
@@ -224,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);
 		}
 	}
@@ -234,7 +256,7 @@ allocation_maillon(struct_processus *s_e
 
 /*
 ================================================================================
-  Routine d'allocation d'un maillon d'un objet (liste, expression...)
+  Routine de libération d'un maillon d'un objet (liste, expression...)
 ================================================================================
   Entrées : structure sur l'état du processus et objet à afficher
 --------------------------------------------------------------------------------
@@ -266,7 +288,7 @@ liberation_maillon(struct_processus *s_e
 ================================================================================
   Routine d'allocation d'une structure *s_objet
 ================================================================================
-  Entrées : structure sur l'état du processus et objet à afficher
+  Entrées : structure sur l'état du processus et objet à allouer
 --------------------------------------------------------------------------------
   Sorties : chaine de caractères
 --------------------------------------------------------------------------------
@@ -274,17 +296,30 @@ liberation_maillon(struct_processus *s_e
 ================================================================================
 */
 
-void *
+struct_objet *
 allocation(struct_processus *s_etat_processus, enum t_type type)
 {
 	struct_objet			*s_objet;
 
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
 	if ((*s_etat_processus).pile_objets == NULL)
 	{
+		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return(NULL);
+		}
+
 		// Il n'existe aucune structure struct_objet disponible dans le cache.
 
 		if ((s_objet = malloc(sizeof(struct_objet))) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
@@ -299,6 +334,12 @@ allocation(struct_processus *s_etat_proc
 		(*s_etat_processus).taille_pile_objets--;
 
 		(*s_objet).nombre_occurrences = 1;
+
+		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return(NULL);
+		}
 	}
 
 	(*s_objet).type = type;
@@ -314,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);
 				}
@@ -341,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);
 				}
@@ -367,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);
 				}
@@ -379,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);
 			}
@@ -398,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);
 				}
@@ -421,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);
 				}
@@ -446,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);
 				}
@@ -469,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);
 				}
@@ -492,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);
 				}
@@ -508,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;
 		}
 
@@ -526,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);
 				}
@@ -545,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);
 			}
@@ -563,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);
 				}
@@ -581,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);
 			}
@@ -593,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);
 			}
@@ -604,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);
 			}
@@ -616,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);
 			}
@@ -634,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);
 				}
@@ -655,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);
 				}
@@ -677,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);
 				}
@@ -699,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);
 				}
@@ -743,7 +820,7 @@ liberation(struct_processus *s_etat_proc
 	struct_liste_chainee				*l_element_courant;
 	struct_liste_chainee				*l_element_suivant;
 
-	unsigned long						i;
+	integer8							i;
 
 	if (s_objet == NULL)
 	{
@@ -782,7 +859,7 @@ liberation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				free((unsigned long *) ((*s_objet).objet));
+				free((*s_objet).objet);
 			}
 
 			break;
@@ -1071,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;
 		}
@@ -1104,14 +1203,13 @@ liberation(struct_processus *s_etat_proc
 				return;
 			}
 
-			free(s_objet);
 			break;
 		}
 
 		case PRC :
 		{
 			if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
-					(*s_objet).objet)).thread).mutex)) != 0)
+					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -1121,7 +1219,8 @@ liberation(struct_processus *s_etat_proc
 					.nombre_references--;
 
 			BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
-					.nombre_references < 0, printf("(*(*((struct_processus_fils"
+					.nombre_references < 0, uprintf(
+					"(*(*((struct_processus_fils"
 					" *) (*s_objet).objet)).thread).nombre_references = %d\n",
 					(int) (*(*((struct_processus_fils *) (*s_objet).objet))
 					.thread).nombre_references));
@@ -1137,7 +1236,7 @@ liberation(struct_processus *s_etat_proc
 			}
 
 			if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
-					(*s_objet).objet)).thread).mutex)) != 0)
+					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -1147,11 +1246,16 @@ liberation(struct_processus *s_etat_proc
 			{
 				pthread_mutex_destroy(&((*(*((struct_processus_fils *)
 						(*s_objet).objet)).thread).mutex));
+				pthread_mutex_destroy(&((*(*((struct_processus_fils *)
+						(*s_objet).objet)).thread).mutex_nombre_references));
 				free((*((struct_processus_fils *) (*s_objet).objet)).thread);
 			}
 
 			if (decrementation_atomique(s_objet) > 0)
 			{
+				BUG(drapeau == d_vrai, uprintf("(*(*((struct_processus_fils"
+						" *) (*s_objet).objet)).thread).nombre_references "
+						"= 0 with nombre_occurrences > 0\n"));
 				return;
 			}
 
@@ -1290,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 *)
@@ -1416,30 +1520,36 @@ liberation(struct_processus *s_etat_proc
 		return;
 	}
 
-	if (s_etat_processus != NULL)
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0)
 	{
-		if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
-		{
-			(*s_objet).objet = (*s_etat_processus).pile_objets;
-			(*s_etat_processus).pile_objets = s_objet;
-			(*s_etat_processus).taille_pile_objets++;
-		}
-		else
-		{
-			if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
 
-			free(s_objet);
-		}
+	if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
+	{
+		(*s_objet).objet = (*s_etat_processus).pile_objets;
+		(*s_etat_processus).pile_objets = s_objet;
+		(*s_etat_processus).taille_pile_objets++;
 	}
 	else
 	{
+		if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
+		{
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation));
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		free(s_objet);
 	}
 
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
+
 	return;
 }
 
@@ -1479,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)
 	{
@@ -1531,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;
 		}
 
@@ -1597,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'
@@ -1649,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)));
 
@@ -1743,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'
@@ -1950,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
@@ -1985,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)
@@ -2009,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++)
 					{
@@ -2052,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)
@@ -2076,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++)
@@ -2119,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)
@@ -2143,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++)
 					{
@@ -2173,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 :
@@ -2228,19 +2325,24 @@ 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 :
 		{
 			if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
-					(*s_objet).objet)).thread).mutex)) != 0)
+					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
 				return(NULL);
 			}
@@ -2249,7 +2351,7 @@ copie_objet(struct_processus *s_etat_pro
 					.nombre_references++;
 
 			if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
-					(*s_objet).objet)).thread).mutex)) != 0)
+					(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
 			{
 				return(NULL);
 			}
@@ -2441,6 +2543,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;
@@ -2519,8 +2623,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);
 				}
@@ -2580,8 +2685,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
@@ -2623,8 +2728,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
@@ -2666,8 +2771,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
@@ -2730,9 +2835,9 @@ 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);
@@ -2758,18 +2863,17 @@ 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;
 	(*s_nouvel_etat_processus).fichiers_graphiques = NULL;
 	(*s_nouvel_etat_processus).entree_standard = NULL;
 	(*s_nouvel_etat_processus).s_marques = NULL;
@@ -2800,6 +2904,8 @@ copie_etat_processus(struct_processus *s
 	(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
 
 	(*s_nouvel_etat_processus).at_exit = NULL;
+	(*s_nouvel_etat_processus).at_poke = NULL;
+	(*s_nouvel_etat_processus).traitement_at_poke = 'N';
 
 	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
 	{
@@ -2811,10 +2917,17 @@ copie_etat_processus(struct_processus *s
 
 	if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
 	{
-		(*s_nouvel_etat_processus).generateur_aleatoire = NULL;
-	}
+		if (((*s_nouvel_etat_processus).generateur_aleatoire =
+				gsl_rng_clone((*s_etat_processus).generateur_aleatoire))
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
 
-	(*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;
+		gsl_rng_set((*s_nouvel_etat_processus).generateur_aleatoire,
+				gsl_rng_get((*s_etat_processus).generateur_aleatoire));
+	}
 
 	// Copie de la localisation
 
@@ -2834,7 +2947,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);
@@ -2854,7 +2968,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);
@@ -2875,7 +2990,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);
@@ -2899,7 +3015,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -2923,7 +3040,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -2947,7 +3065,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -2971,7 +3090,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -2995,7 +3115,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -3019,7 +3140,8 @@ copie_etat_processus(struct_processus *s
 				(*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);
@@ -3041,135 +3163,18 @@ copie_etat_processus(struct_processus *s
 	 * Copie de la table des variables
 	 */
 
-	if (((*s_nouvel_etat_processus).s_liste_variables =
-			malloc((*s_etat_processus).nombre_variables_allouees *
-			sizeof(struct_variable))) == 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; i++)
-	{
-		if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
-				malloc((strlen((*s_etat_processus).s_liste_variables[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[i].nom,
-				(*s_etat_processus).s_liste_variables[i].nom);
-
-		(*s_nouvel_etat_processus).s_liste_variables[i].origine =
-				(*s_etat_processus).s_liste_variables[i].origine;
-		(*s_nouvel_etat_processus).s_liste_variables[i].niveau =
-				(*s_etat_processus).s_liste_variables[i].niveau;
-		(*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
-				(*s_etat_processus).s_liste_variables[i].variable_statique;
-		(*s_nouvel_etat_processus).s_liste_variables[i].variable_partagee =
-				(*s_etat_processus).s_liste_variables[i].variable_partagee;
-		(*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
-				(*s_etat_processus).s_liste_variables[i].variable_verrouillee;
-
-		// Les définitions sont partagées entre tous les threads.
-
-		if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
-		{
-			(*s_nouvel_etat_processus).s_liste_variables[i].objet =
-					(*s_etat_processus).s_liste_variables[i].objet;
-		}
-		else
-		{
-			if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
-					copie_objet(s_etat_processus,
-					(*s_etat_processus).s_liste_variables[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_statiques = NULL;
+	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
 
-	/*
-	 * 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 ((*s_nouvel_etat_processus).erreur_systeme != d_es)
 	{
-		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
@@ -3183,7 +3188,8 @@ copie_etat_processus(struct_processus *s
 	{
 		if ((l_element_suivant = malloc(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);
@@ -3196,7 +3202,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);
@@ -3232,7 +3239,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);
@@ -3254,7 +3262,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);
@@ -3278,6 +3287,9 @@ 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;
 
@@ -3285,7 +3297,8 @@ copie_etat_processus(struct_processus *s
 	{
 		if ((l_element_suivant = malloc(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 +3311,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);
@@ -3331,7 +3345,8 @@ copie_etat_processus(struct_processus *s
 	{
 		if ((l_element_suivant = malloc(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 +3359,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);
@@ -3382,7 +3398,8 @@ copie_etat_processus(struct_processus *s
 	{
 		if ((l_element_suivant = malloc(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 +3412,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);
@@ -3428,7 +3446,8 @@ copie_etat_processus(struct_processus *s
 	{
 		if ((l_element_suivant = malloc(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);
@@ -3457,7 +3476,8 @@ copie_etat_processus(struct_processus *s
 				malloc((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,7 +3508,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 *
+				malloc(((size_t) (*s_etat_processus)
+				.nombre_instructions_externes) *
 				sizeof(struct_instruction_externe))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -3533,10 +3554,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_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).mutex_allocation),
+			&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);
@@ -3565,20 +3605,24 @@ copie_etat_processus(struct_processus *s
 #undef malloc
 #undef realloc
 #undef free
+#undef fork
 
 #ifdef return
 #	undef return
 #endif
 
-#undef fprintf
-
 #ifdef __BACKTRACE
+#define	PROFONDEUR_PILE	64
 #define return(a) { if (a == NULL) \
-		{ BACKTRACE(20); fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
+		{ BACKTRACE(PROFONDEUR_PILE); \
+		fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
 		return(a); } while(0)
-#define	PROFONDEUR_PILE	64
 #endif
 
+#undef fprintf
+#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
+#undef CORE_DUMP
+
 typedef struct memoire
 {
 	void				*pointeur;
@@ -3596,10 +3640,20 @@ typedef struct memoire
 
 static struct_memoire		*debug = NULL;
 static unsigned long long	ordre = 0;
-static pthread_mutex_t		mutex_allocation = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t		mutex_allocation;
 
-#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
-#undef CORE_DUMP
+void
+debug_memoire_initialisation()
+{
+	pthread_mutexattr_t			attributs_mutex;
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&mutex_allocation, &attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	return;
+}
 
 void *
 debug_memoire_ajout(size_t taille, const unsigned char *fonction,
@@ -3607,6 +3661,8 @@ debug_memoire_ajout(size_t taille, const
 {
 	struct_memoire	*ancienne_base;
 
+	void			*pointeur;
+
 	pthread_mutex_lock(&mutex_allocation);
 
 	ancienne_base = debug;
@@ -3628,6 +3684,8 @@ debug_memoire_ajout(size_t taille, const
 	(*debug).taille = taille;
 	(*debug).ordre = ordre;
 
+	pointeur = (*debug).pointeur;
+
 #	ifdef __BACKTRACE
 	(*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE);
 #	endif
@@ -3649,10 +3707,12 @@ debug_memoire_ajout(size_t taille, const
 	strcpy((*debug).fonction, fonction);
 	strcpy((*debug).argument, argument);
 
+	memset((*debug).pointeur, 0, (*debug).taille);
+
 	pthread_mutex_unlock(&mutex_allocation);
 	ordre++;
 
-	return((*debug).pointeur);
+	return(pointeur);
 }
 
 void *
@@ -3666,9 +3726,11 @@ debug_memoire_modification(void *pointeu
 	{
 		if (taille == 0)
 		{
-			// Revient à free()
+			// Revient à free(). Il n'y a pas de parenthèses car on ne veut
+			// pas utiliser la macro return().
+
 			debug_memoire_retrait(pointeur);
-			return(NULL);
+			return NULL ;
 		}
 		else
 		{
@@ -3691,41 +3753,50 @@ debug_memoire_modification(void *pointeu
 			if (element_courant == NULL)
 			{
 				pthread_mutex_unlock(&mutex_allocation);
-				return(NULL);
-			}
 
-			if (((*element_courant).pointeur = realloc(pointeur, taille))
-					== NULL)
-			{
-				pthread_mutex_unlock(&mutex_allocation);
-				return(NULL);
+				uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
+						getpid(), (unsigned long long) pthread_self());
+#				ifdef __BACKTRACE
+					BACKTRACE(PROFONDEUR_PILE);
+#				endif
+
+				return(realloc(pointeur, taille));
 			}
+			else
+			{
+				if (((*element_courant).pointeur = realloc(pointeur, taille))
+						== NULL)
+				{
+					pthread_mutex_unlock(&mutex_allocation);
+					return(NULL);
+				}
 
-			(*element_courant).ligne = ligne;
-			(*element_courant).taille = taille;
-			free((*element_courant).fonction);
-			free((*element_courant).argument);
+				(*element_courant).ligne = ligne;
+				(*element_courant).taille = taille;
+				free((*element_courant).fonction);
+				free((*element_courant).argument);
 
-			if (((*element_courant).fonction = malloc((strlen(fonction) + 1) *
-					sizeof(unsigned char))) == NULL)
-			{
-				pthread_mutex_unlock(&mutex_allocation);
-				return(NULL);
-			}
+				if (((*element_courant).fonction = malloc((strlen(fonction)
+						+ 1) * sizeof(unsigned char))) == NULL)
+				{
+					pthread_mutex_unlock(&mutex_allocation);
+					return(NULL);
+				}
 
-			if (((*element_courant).argument = malloc((strlen(argument) + 1) *
-					sizeof(unsigned char))) == NULL)
-			{
-				pthread_mutex_unlock(&mutex_allocation);
-				return(NULL);
-			}
+				if (((*element_courant).argument = malloc((strlen(argument)
+						+ 1) * sizeof(unsigned char))) == NULL)
+				{
+					pthread_mutex_unlock(&mutex_allocation);
+					return(NULL);
+				}
 
-			strcpy((*element_courant).fonction, fonction);
-			strcpy((*element_courant).argument, argument);
+				strcpy((*element_courant).fonction, fonction);
+				strcpy((*element_courant).argument, argument);
 
-			pthread_mutex_unlock(&mutex_allocation);
+				pthread_mutex_unlock(&mutex_allocation);
 
-			return((*element_courant).pointeur);
+				return((*element_courant).pointeur);
+			}
 		}
 	}
 	else
@@ -3760,6 +3831,11 @@ debug_memoire_retrait(void *pointeur)
 				(*element_precedent).suivant = (*element_courant).suivant;
 			}
 
+			if (pointeur != NULL)
+			{
+				memset(pointeur, 0, (*element_courant).taille);
+			}
+
 			free((*element_courant).fonction);
 			free((*element_courant).argument);
 			free(element_courant);
@@ -3773,8 +3849,16 @@ debug_memoire_retrait(void *pointeur)
 
 	pthread_mutex_unlock(&mutex_allocation);
 
-	free(pointeur);
+	if (element_courant == NULL)
+	{
+		uprintf("[%d-%llu] ILLEGAL POINTER (free)\n",
+				getpid(), (unsigned long long) pthread_self());
+#		ifdef __BACKTRACE
+			BACKTRACE(PROFONDEUR_PILE);
+#		endif
+	}
 
+	free(pointeur);
 	return;
 }
 
@@ -3876,6 +3960,7 @@ debug_memoire_verification()
 	}
 
 	pthread_mutex_unlock(&mutex_allocation);
+	pthread_mutex_destroy(&mutex_allocation);
 
 	fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
 			(unsigned long long) pthread_self());
@@ -3883,16 +3968,29 @@ debug_memoire_verification()
 	return;
 }
 
-void
-debug_memoire_reinitialisation()
+pid_t
+debug_fork()
 {
-	ordre = 0;
-	debug = NULL;
+	pid_t	pid;
 
-	pthread_mutex_trylock(&mutex_allocation);
-	pthread_mutex_unlock(&mutex_allocation);
+	pthread_mutex_lock(&mutex_allocation);
+	pid = fork();
 
-	return;
+	if (pid == 0)
+	{
+		liberation_queue_signaux(s_etat_processus);
+		creation_queue_signaux(s_etat_processus);
+
+		pthread_mutex_destroy(&mutex_allocation);
+		debug_memoire_initialisation();
+	}
+	else
+	{
+		pthread_mutex_unlock(&mutex_allocation);
+	}
+
+	// Pas de parenthèses pour ne pas remplacer return par sa macro.
+	return pid;
 }
 
 void