--- rpl/src/gestion_objets.c	2012/04/03 21:27:09	1.80
+++ rpl/src/gestion_objets.c	2020/01/10 11:15:42	1.148
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.7
-  Copyright (C) 1989-2012 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -106,15 +106,18 @@ initialisation_allocateur(struct_process
 	(*s_etat_processus).pointeur_int = 0;
 	(*s_etat_processus).pointeur_mat = 0;
 	(*s_etat_processus).pointeur_nom = 0;
+	(*s_etat_processus).pointeur_rec = 0;
 	(*s_etat_processus).pointeur_rel = 0;
 	(*s_etat_processus).pointeur_tab = 0;
 	(*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;
 }
@@ -139,6 +142,8 @@ liberation_allocateur(struct_processus *
 			free((*s_etat_processus).objets_mat[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_nom;
 			free((*s_etat_processus).objets_nom[i++]));
+	for(i = 0; i < (*s_etat_processus).pointeur_rec;
+			free((*s_etat_processus).objets_rec[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_rel;
 			free((*s_etat_processus).objets_rel[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_tab;
@@ -150,12 +155,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 +248,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 +322,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);
 		}
 
@@ -334,6 +346,8 @@ allocation(struct_processus *s_etat_proc
 	}
 
 	(*s_objet).type = type;
+	(*s_objet).extension_type = 0;
+	(*s_objet).descripteur_bibliotheque = NULL;
 
 	switch(type)
 	{
@@ -346,8 +360,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 +389,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 +417,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 +431,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);
 			}
@@ -418,6 +439,12 @@ allocation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT :
+		{
+			// Aucune allocation
+			break;
+		}
+
 		case FCT :
 		{
 			if ((*s_etat_processus).pointeur_fct > 0)
@@ -430,6 +457,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 +482,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 +509,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 +534,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 +559,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,6 +577,7 @@ 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);
 			}
@@ -559,6 +597,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);
 				}
@@ -578,6 +618,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);
 			}
@@ -585,6 +626,28 @@ allocation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case REC :
+		{
+			if ((*s_etat_processus).pointeur_rec > 0)
+			{
+				(*s_objet).objet = (*s_etat_processus).objets_rec
+						[--(*s_etat_processus).pointeur_rec];
+			}
+			else
+			{
+				if (((*s_objet).objet = malloc(sizeof(struct_record)))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					free(s_objet);
+					return(NULL);
+				}
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if ((*s_etat_processus).pointeur_rel > 0)
@@ -596,6 +659,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);
 				}
@@ -614,6 +679,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);
 			}
@@ -626,6 +692,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);
 			}
@@ -637,6 +704,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);
 			}
@@ -649,6 +717,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);
 			}
@@ -667,6 +736,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);
 				}
@@ -688,6 +759,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);
 				}
@@ -710,6 +783,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);
 				}
@@ -732,6 +807,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);
 				}
@@ -776,7 +853,9 @@ liberation(struct_processus *s_etat_proc
 	struct_liste_chainee				*l_element_courant;
 	struct_liste_chainee				*l_element_suivant;
 
-	unsigned long						i;
+	integer8							i;
+	integer8							(*__type_drop)(struct_processus *,
+												void **);
 
 	if (s_objet == NULL)
 	{
@@ -815,7 +894,7 @@ liberation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				free((unsigned long *) ((*s_objet).objet));
+				free((*s_objet).objet);
 			}
 
 			break;
@@ -882,7 +961,7 @@ liberation(struct_processus *s_etat_proc
 				return;
 			}
 
-			free((unsigned char *) ((*s_objet).objet));
+			free((unsigned char *) (*s_objet).objet);
 			break;
 		}
 
@@ -1219,6 +1298,31 @@ liberation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case REC :
+		{
+			liberation(s_etat_processus,
+					(*((struct_record *) (*s_objet).objet)).noms);
+			liberation(s_etat_processus,
+					(*((struct_record *) (*s_objet).objet)).donnees);
+
+			if (decrementation_atomique(s_objet) > 0)
+			{
+				return;
+			}
+
+			if ((*s_etat_processus).pointeur_rec < TAILLE_CACHE)
+			{
+				(*s_etat_processus).objets_rec
+						[(*s_etat_processus).pointeur_rec++] = (*s_objet).objet;
+			}
+			else
+			{
+				free((struct_record *) ((*s_objet).objet));
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if (decrementation_atomique(s_objet) > 0)
@@ -1350,7 +1454,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 *)
@@ -1449,6 +1553,57 @@ liberation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT:
+		{
+			if (decrementation_atomique(s_objet) > 0)
+			{
+				return;
+			}
+
+			// Appel de la fonction de liberation associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_drop = dlsym((*s_objet)
+							.descripteur_bibliotheque, "__type_drop")) == NULL)
+					{
+						// La fonction de libération n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_drop;
+					}
+					else
+					{
+						if (__type_drop(s_etat_processus, (void **) &s_objet)
+								== 0)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_type_externe_drop;
+						}
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_drop;
+			}
+
+			break;
+		}
+
 		default :
 		{
 			if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
@@ -1545,8 +1700,9 @@ 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;
+	integer8					(*__type_dup)(struct_processus *, void **);
 
 	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
 	{
@@ -1597,8 +1753,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;
 		}
 
@@ -1663,7 +1819,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'
@@ -1715,7 +1871,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)));
 
@@ -1809,7 +1965,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'
@@ -2016,7 +2172,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
@@ -2051,9 +2207,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)
@@ -2075,9 +2230,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++)
 					{
@@ -2118,9 +2273,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)
@@ -2142,9 +2297,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++)
@@ -2185,9 +2340,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)
@@ -2209,9 +2363,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++)
 					{
@@ -2283,12 +2437,17 @@ 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;
 		}
 
@@ -2325,6 +2484,46 @@ copie_objet(struct_processus *s_etat_pro
 			break;
 		}
 
+		case REC :
+		{
+			if (type != 'P')
+			{
+				if ((s_nouvel_objet = allocation(s_etat_processus, REC))
+						== NULL)
+				{
+					return(NULL);
+				}
+
+				if (((*((struct_record *) (*s_nouvel_objet).objet)).noms =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).noms, 'P')) == NULL)
+				{
+					return(NULL);
+				}
+
+				if (((*((struct_record *) (*s_nouvel_objet).objet)).donnees =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).donnees, type)) == NULL)
+				{
+					return(NULL);
+				}
+			}
+			else
+			{
+				incrementation_atomique(s_objet);
+				(*((struct_record *) (*s_objet).objet)).noms =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).noms, 'P');
+				(*((struct_record *) (*s_objet).objet)).donnees =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).donnees, 'P');
+
+				return(s_objet);
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if (type != 'O')
@@ -2387,6 +2586,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 *)
@@ -2576,8 +2787,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);
 				}
@@ -2637,8 +2849,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
@@ -2680,8 +2892,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
@@ -2723,8 +2935,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
@@ -2752,6 +2964,59 @@ copie_objet(struct_processus *s_etat_pro
 			break;
 		}
 
+		case EXT:
+		{
+			if (type != 'O')
+			{
+				incrementation_atomique(s_objet);
+				return(s_objet);
+			}
+
+			// Appel de la fonction de duplication associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_dup = dlsym((*s_objet).descripteur_bibliotheque,
+							"__type_dup")) == NULL)
+					{
+						// La fonction de duplication n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_dup;
+						return(NULL);
+					}
+
+					s_nouvel_objet = s_objet;
+
+					if (__type_dup(s_etat_processus, (void **) &s_nouvel_objet)
+							== 0)
+					{
+						return(NULL);
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_dup;
+				return(NULL);
+			}
+
+			break;
+		}
+
 		default :
 		{
 			return(NULL);
@@ -2787,25 +3052,71 @@ 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);
 	}
 
+
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
 	(*s_nouvel_etat_processus) = (*s_etat_processus);
 
-	// On réinitialise l'allocateur.
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
+	// 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,
@@ -2815,8 +3126,8 @@ copie_etat_processus(struct_processus *s
 	 * n'ont aucune raison de changer.
 	 */
 
-	pthread_mutexattr_init(&attributs_mutex);
-	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	(*s_nouvel_etat_processus).sections_critiques = 0;
+	(*s_nouvel_etat_processus).initialisation_scheduler = d_faux;
 
 	// Les sémaphores sont initialisés dans le nouveau thread. Il
 	// s'agit d'une limitation de l'implantation de l'émulation
@@ -2883,9 +3194,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);
@@ -2899,7 +3210,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);
@@ -2919,7 +3231,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);
@@ -2940,7 +3253,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);
@@ -2960,11 +3274,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);
@@ -2984,11 +3300,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);
@@ -3008,11 +3326,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);
@@ -3032,11 +3351,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);
@@ -3056,11 +3376,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);
@@ -3080,11 +3401,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);
@@ -3106,6 +3428,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)
@@ -3113,65 +3436,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
@@ -3183,9 +3451,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);
@@ -3198,7 +3468,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);
@@ -3234,7 +3505,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);
@@ -3256,7 +3528,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);
@@ -3288,9 +3561,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);
@@ -3303,7 +3578,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);
@@ -3334,9 +3610,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);
@@ -3349,7 +3627,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);
@@ -3385,9 +3664,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);
@@ -3400,7 +3681,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);
@@ -3431,9 +3713,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);
@@ -3443,8 +3727,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);
@@ -3459,10 +3743,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);
@@ -3493,7 +3779,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;
@@ -3503,7 +3790,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;
@@ -3514,9 +3802,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);
@@ -3538,16 +3826,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);
@@ -3665,6 +3966,13 @@ debug_memoire_ajout(size_t taille, const
 			sizeof(unsigned char))) == NULL)
 	{
 		pthread_mutex_unlock(&mutex_allocation);
+
+		uprintf("[%d-%llu] ILLEGAL POINTER (malloc) $%016X\n",
+				getpid(), (unsigned long long) pthread_self(), NULL);
+#		ifdef __BACKTRACE
+			BACKTRACE(PROFONDEUR_PILE);
+#		endif
+
 		return(NULL);
 	}
 
@@ -3725,8 +4033,9 @@ debug_memoire_modification(void *pointeu
 			{
 				pthread_mutex_unlock(&mutex_allocation);
 
-				uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
-						getpid(), (unsigned long long) pthread_self());
+				uprintf("[%d-%llu] ILLEGAL POINTER (realloc) $%016X\n",
+						getpid(), (unsigned long long) pthread_self(),
+						pointeur);
 #				ifdef __BACKTRACE
 					BACKTRACE(PROFONDEUR_PILE);
 #				endif
@@ -3822,8 +4131,8 @@ debug_memoire_retrait(void *pointeur)
 
 	if (element_courant == NULL)
 	{
-		uprintf("[%d-%llu] ILLEGAL POINTER (free)\n",
-				getpid(), (unsigned long long) pthread_self());
+		uprintf("[%d-%llu] ILLEGAL POINTER (free) $%016X\n",
+				getpid(), (unsigned long long) pthread_self(), pointeur);
 #		ifdef __BACKTRACE
 			BACKTRACE(PROFONDEUR_PILE);
 #		endif
@@ -3940,7 +4249,7 @@ debug_memoire_verification()
 }
 
 pid_t
-debug_fork()
+debug_fork(struct_processus *s_etat_processus)
 {
 	pid_t	pid;