--- rpl/src/gestion_objets.c	2015/09/15 19:18:46	1.122
+++ rpl/src/gestion_objets.c	2018/05/30 09:27:32	1.138
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.22
-  Copyright (C) 1989-2015 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.29
+  Copyright (C) 1989-2018 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -343,6 +343,8 @@ allocation(struct_processus *s_etat_proc
 	}
 
 	(*s_objet).type = type;
+	(*s_objet).extension_type = 0;
+	(*s_objet).descripteur_bibliotheque = NULL;
 
 	switch(type)
 	{
@@ -434,6 +436,12 @@ allocation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT :
+		{
+			// Aucune allocation
+			break;
+		}
+
 		case FCT :
 		{
 			if ((*s_etat_processus).pointeur_fct > 0)
@@ -821,6 +829,8 @@ liberation(struct_processus *s_etat_proc
 	struct_liste_chainee				*l_element_suivant;
 
 	integer8							i;
+	integer8							(*__type_drop)(struct_processus *,
+												void **);
 
 	if (s_objet == NULL)
 	{
@@ -1493,6 +1503,57 @@ liberation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case EXT:
+		{
+			if (decrementation_atomique(s_objet) > 0)
+			{
+				return;
+			}
+
+			// Appel de la fonction de liberation associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_drop = dlsym((*s_objet)
+							.descripteur_bibliotheque, "__type_drop")) == NULL)
+					{
+						// La fonction de libération n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_drop;
+					}
+					else
+					{
+						if (__type_drop(s_etat_processus, (void **) &s_objet)
+								== 0)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_type_externe_drop;
+						}
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_drop;
+			}
+
+			break;
+		}
+
 		default :
 		{
 			if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
@@ -1591,6 +1652,7 @@ copie_objet(struct_processus *s_etat_pro
 
 	integer8					i;
 	integer8					j;
+	integer8					(*__type_dup)(struct_processus *, void **);
 
 	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
 	{
@@ -2812,6 +2874,59 @@ copie_objet(struct_processus *s_etat_pro
 			break;
 		}
 
+		case EXT:
+		{
+			if (type != 'O')
+			{
+				incrementation_atomique(s_objet);
+				return(s_objet);
+			}
+
+			// Appel de la fonction de duplication associée à l'objet
+			// externe. Le descripteur de bibliothèque est directement
+			// associé à la structure objet.
+
+			l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+			while(l_element_courant != NULL)
+			{
+				if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
+						.descripteur == (*s_objet).descripteur_bibliotheque)
+				{
+					if ((__type_dup = dlsym((*s_objet).descripteur_bibliotheque,
+							"__type_dup")) == NULL)
+					{
+						// La fonction de duplication n'existe pas dans la
+						// bibliothèque.
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_type_externe_dup;
+						return(NULL);
+					}
+
+					s_nouvel_objet = s_objet;
+
+					if (__type_dup(s_etat_processus, (void **) &s_nouvel_objet)
+							== 0)
+					{
+						return(NULL);
+					}
+
+					break;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			if (l_element_courant == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_type_externe_dup;
+				return(NULL);
+			}
+
+			break;
+		}
+
 		default :
 		{
 			return(NULL);
@@ -2858,6 +2973,13 @@ copie_etat_processus(struct_processus *s
 	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);
 	}
@@ -3605,6 +3727,12 @@ copie_etat_processus(struct_processus *s
 			&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;