--- rpl/src/gestion_objets.c	2010/04/27 15:53:36	1.13
+++ rpl/src/gestion_objets.c	2013/05/28 22:09:55	1.104
@@ -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.14
+  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;
@@ -877,12 +954,21 @@ liberation(struct_processus *s_etat_proc
 		{
 			if (decrementation_atomique(s_objet) > 0)
 			{
+				BUG((*(*((struct_fichier *) (*s_objet).objet)).format)
+						.nombre_occurrences <= 1,
+						pthread_mutex_unlock(&((*s_objet).mutex)),
+						printf("(*(*((struct_fichier *) (*s_objet).objet))"
+						".format).nombre_occurrences=%ld\n",
+						(*(*((struct_fichier *) (*s_objet).objet)).format)
+						.nombre_occurrences));
+
+				liberation(s_etat_processus,
+						(*((struct_fichier *) (*s_objet).objet)).format);
 				return;
 			}
 
 			liberation(s_etat_processus,
 					(*((struct_fichier *) (*s_objet).objet)).format);
-
 			free((unsigned char *) (*((struct_fichier *)
 					(*s_objet).objet)).nom);
 			free((struct_fichier *) ((*s_objet).objet));
@@ -1062,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;
 		}
@@ -1095,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;
@@ -1112,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));
@@ -1128,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;
@@ -1138,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;
 			}
 
@@ -1208,11 +1321,22 @@ liberation(struct_processus *s_etat_proc
 		{
 			if (decrementation_atomique(s_objet) > 0)
 			{
+				BUG((*(*((struct_socket *) (*s_objet).objet)).format)
+						.nombre_occurrences <= 1,
+						pthread_mutex_unlock(&((*s_objet).mutex)),
+						printf("(*(*((struct_socket *) (*s_objet).objet))"
+						".format).nombre_occurrences=%ld\n",
+						(*(*((struct_socket *) (*s_objet).objet)).format)
+						.nombre_occurrences));
+
+				liberation(s_etat_processus, (*((struct_socket *)
+						(*s_objet).objet)).format);
 				return;
 			}
 
 			liberation(s_etat_processus, (*((struct_socket *)
 					(*s_objet).objet)).format);
+
 			free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
 					.adresse);
 			free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
@@ -1270,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 *)
@@ -1396,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;
 }
 
@@ -1459,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)
 	{
@@ -1511,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;
 		}
 
@@ -1577,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'
@@ -1629,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)));
 
@@ -1723,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'
@@ -1749,6 +1879,14 @@ copie_objet(struct_processus *s_etat_pro
 			if (type == 'P')
 			{
 				incrementation_atomique(s_objet);
+
+				if (((*((struct_fichier *) ((*s_objet).objet))).format =
+						copie_objet(s_etat_processus, (*((struct_fichier *)
+						((*s_objet).objet))).format, 'P')) == NULL)
+				{
+					return(NULL);
+				}
+
 				return(s_objet);
 			}
 
@@ -1922,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
@@ -1957,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)
@@ -1981,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++)
 					{
@@ -2024,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)
@@ -2048,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++)
@@ -2091,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)
@@ -2115,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++)
 					{
@@ -2145,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 :
@@ -2200,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);
 			}
@@ -2221,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);
 			}
@@ -2265,6 +2395,15 @@ copie_objet(struct_processus *s_etat_pro
 			if (type == 'P')
 			{
 				incrementation_atomique(s_objet);
+
+				if (((*((struct_socket *) ((*s_objet).objet)))
+						.format = copie_objet(s_etat_processus,
+						(*((struct_socket *) ((*s_objet).objet))).format, 'P'))
+						== NULL)
+				{
+					return(NULL);
+				}
+
 				return(s_objet);
 			}
 
@@ -2404,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;
@@ -2482,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);
 				}
@@ -2543,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
@@ -2586,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
@@ -2629,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
@@ -2693,7 +2835,7 @@ 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)
 	{
@@ -2721,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;
@@ -2762,7 +2903,9 @@ copie_etat_processus(struct_processus *s
 	(*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
 	(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
 
-	(*s_nouvel_etat_processus).on_exit = NULL;
+	(*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++)
 	{
@@ -2774,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
 
@@ -3004,135 +3154,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);
-			}
-		}
-	}
-
-	/*
-	 * Copie de la table des variables statiques
-	 */
+	(*s_nouvel_etat_processus).l_liste_variables_statiques = NULL;
+	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
 
-	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
@@ -3241,6 +3274,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;
 
@@ -3451,7 +3487,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;
@@ -3499,6 +3536,18 @@ copie_etat_processus(struct_processus *s
 	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &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_allocation),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
 	if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -3528,16 +3577,23 @@ 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)
+#endif
+
+#undef fprintf
+#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
+#undef CORE_DUMP
 
 typedef struct memoire
 {
@@ -3547,14 +3603,29 @@ typedef struct memoire
 	unsigned long		ligne;
 	size_t				taille;
 	unsigned long long	ordre;
+#	ifdef __BACKTRACE
+	void				*pile[PROFONDEUR_PILE];
+	int					profondeur;
+#	endif
 	struct memoire		*suivant;
 } 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))
+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,
@@ -3562,6 +3633,8 @@ debug_memoire_ajout(size_t taille, const
 {
 	struct_memoire	*ancienne_base;
 
+	void			*pointeur;
+
 	pthread_mutex_lock(&mutex_allocation);
 
 	ancienne_base = debug;
@@ -3583,26 +3656,35 @@ debug_memoire_ajout(size_t taille, const
 	(*debug).taille = taille;
 	(*debug).ordre = ordre;
 
-	pthread_mutex_unlock(&mutex_allocation);
+	pointeur = (*debug).pointeur;
+
+#	ifdef __BACKTRACE
+	(*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE);
+#	endif
 
 	if (((*debug).fonction = malloc((strlen(fonction) + 1) *
 			sizeof(unsigned char))) == NULL)
 	{
+		pthread_mutex_unlock(&mutex_allocation);
 		return(NULL);
 	}
 
 	if (((*debug).argument = malloc((strlen(argument) + 1) *
 			sizeof(unsigned char))) == NULL)
 	{
+		pthread_mutex_unlock(&mutex_allocation);
 		return(NULL);
 	}
 
 	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 *
@@ -3616,9 +3698,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
 		{
@@ -3641,38 +3725,50 @@ debug_memoire_modification(void *pointeu
 			if (element_courant == NULL)
 			{
 				pthread_mutex_unlock(&mutex_allocation);
-				return(NULL);
-			}
 
-			pthread_mutex_unlock(&mutex_allocation);
+				uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
+						getpid(), (unsigned long long) pthread_self());
+#				ifdef __BACKTRACE
+					BACKTRACE(PROFONDEUR_PILE);
+#				endif
 
-			if (((*element_courant).pointeur = realloc(pointeur, taille))
-					== NULL)
-			{
-				return(NULL);
+				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)
-			{
-				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)
-			{
-				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);
 
-			return((*element_courant).pointeur);
+				return((*element_courant).pointeur);
+			}
 		}
 	}
 	else
@@ -3707,6 +3803,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);
@@ -3720,20 +3821,34 @@ 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;
 }
 
 void
-debug_memoire_verification(struct_processus *s_etat_processus)
+debug_memoire_verification()
 {
+#	ifdef __BACKTRACE
+	char			**appels;
+
+	int				j;
+#	endif
+
 	integer8		i;
 
 	struct_memoire	*element_courant;
 	struct_memoire	*element_suivant;
 
-	fprintf(stderr, "[%d-%llu] MEMORY LEAK\n",
+	fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n",
 			getpid(), (unsigned long long) pthread_self());
 
 	pthread_mutex_lock(&mutex_allocation);
@@ -3755,31 +3870,112 @@ debug_memoire_verification(struct_proces
 				(unsigned long long) pthread_self(),
 				(*element_courant).argument);
 
-		switch(i)
+		if (strstr((*element_courant).argument, "sizeof(unsigned char)")
+				!= NULL)
+		{
+			fprintf(stderr, "[%d-%llu] ", getpid(),
+					(unsigned long long) pthread_self());
+			fprintf(stderr, "O: %s\n", (unsigned char *)
+					(*element_courant).pointeur);
+		}
+		else if (strcmp((*element_courant).argument, "sizeof(struct_objet)")
+				== 0)
 		{
-			// Affichage des méditations
-			case 1:
+			fprintf(stderr, "[%d-%llu] ", getpid(),
+					(unsigned long long) pthread_self());
+			fprintf(stderr, "O: %d\n", (*((struct_objet *)
+					(*element_courant).pointeur)).type);
+		}
+		else if (strcmp((*element_courant).argument,
+				"sizeof(struct_liste_chainee)") == 0)
+		{
+			fprintf(stderr, "[%d-%llu] ", getpid(),
+					(unsigned long long) pthread_self());
+			fprintf(stderr, "O: data=%p next=%p\n", (*((struct_liste_chainee *)
+					(*element_courant).pointeur)).donnee,
+					(*((struct_liste_chainee *) (*element_courant).pointeur))
+					.suivant);
+		}
+
+#		ifdef __BACKTRACE
+		appels = backtrace_symbols((*element_courant).pile,
+				(*element_courant).profondeur);
+
+		fprintf(stderr, "[%d-%llu] BACKTRACE\n",
+				getpid(), (unsigned long long) pthread_self());
+
+		if (appels != NULL)
+		{
+			for(j = 0; j < (*element_courant).profondeur; j++)
 			{
-				break;
+				fprintf(stderr, "[%d-%llu] %s\n", getpid(),
+						(unsigned long long) pthread_self(), appels[j]);
 			}
+
+			free(appels);
 		}
+#		endif
+
+		fprintf(stderr, "\n");
 
 		i++;
 
 		element_suivant = (*element_courant).suivant;
+
+#		ifndef CORE_DUMP
 		free((*element_courant).fonction);
 		free((*element_courant).argument);
 		free(element_courant);
+#		endif
+
 		element_courant = element_suivant;
 	}
 
 	pthread_mutex_unlock(&mutex_allocation);
+	pthread_mutex_destroy(&mutex_allocation);
 
 	fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
 			(unsigned long long) pthread_self());
 
 	return;
 }
+
+pid_t
+debug_fork()
+{
+	pid_t	pid;
+
+	pthread_mutex_lock(&mutex_allocation);
+	pid = fork();
+
+	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
+analyse_post_mortem()
+{
+#	ifdef CORE_DUMP
+	BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR "
+			"POST MORTEM ANALYZE\n", getpid(),
+			(unsigned long long) pthread_self()));
+#	endif
+
+	return;
+}
 
 #endif