--- rpl/src/instructions_p7.c	2010/05/13 19:09:18	1.9
+++ rpl/src/instructions_p7.c	2022/09/07 13:40:38	1.86
@@ -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.34
+  Copyright (C) 1989-2021 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -94,8 +94,8 @@ instruction_protect(struct_processus *s_
 			return;
 		}
 
-		((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante]).variable_verrouillee = d_vrai;
+		(*(*s_etat_processus).pointeur_variable_courante)
+				.variable_verrouillee = d_vrai;
 	}
 	else if ((*s_objet).type == LST)
 	{
@@ -122,8 +122,8 @@ instruction_protect(struct_processus *s_
 				return;
 			}
 
-			((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante]).variable_verrouillee = d_vrai;
+			(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_verrouillee = d_vrai;
 
 			l_element_courant = (*l_element_courant).suivant;
 		}
@@ -157,10 +157,6 @@ instruction_protect(struct_processus *s_
 void
 instruction_parameter(struct_processus *s_etat_processus)
 {
-	logical1							presence_variable;
-
-	long								i;
-
 	struct_liste_chainee				*l_element_courant;
 
 	struct_objet						*s_objet;
@@ -207,7 +203,7 @@ instruction_parameter(struct_processus *
 
 	if ((*s_objet).type == NOM)
 	{
-		if (recherche_variable(s_etat_processus, ((*((struct_nom *)
+		if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
 				(*s_objet).objet)).nom)) == d_faux)
 		{
 			liberation(s_etat_processus, s_objet);
@@ -217,34 +213,8 @@ instruction_parameter(struct_processus *
 			return;
 		}
 
-		i = (*s_etat_processus).position_variable_courante;
-		presence_variable = d_faux;
-
-		while(i >= 0)
-		{
-			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
-					(*((struct_nom *) (*s_objet).objet)).nom) == 0)
-					&& ((*s_etat_processus).s_liste_variables[i].niveau == 1))
-			{
-				presence_variable = d_vrai;
-				break;
-			}
-
-			i--;
-		}
-
-		(*s_etat_processus).position_variable_courante = i;
-
-		if (presence_variable == d_faux)
-		{
-			liberation(s_etat_processus, s_objet);
-
-			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
-			return;
-		}
-
-		((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante]).variable_verrouillee = d_vrai;
+		(*(*s_etat_processus).pointeur_variable_courante)
+				.variable_verrouillee = d_vrai;
 	}
 	else if ((*s_objet).type == LST)
 	{
@@ -260,7 +230,7 @@ instruction_parameter(struct_processus *
 				return;
 			}
 
-			if (recherche_variable(s_etat_processus, (*((struct_nom *)
+			if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
 					(*(*l_element_courant).donnee).objet)).nom) == d_faux)
 			{
 				liberation(s_etat_processus, s_objet);
@@ -271,36 +241,8 @@ instruction_parameter(struct_processus *
 				return;
 			}
 
-			i = (*s_etat_processus).position_variable_courante;
-			presence_variable = d_faux;
-
-			while(i >= 0)
-			{
-				if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
-						(*((struct_nom *) (*(*l_element_courant).donnee)
-						.objet)).nom) == 0) && ((*s_etat_processus)
-						.s_liste_variables[i].niveau == 1))
-				{
-					presence_variable = d_vrai;
-					break;
-				}
-
-				i--;
-			}
-
-			(*s_etat_processus).position_variable_courante = i;
-
-			if (presence_variable == d_faux)
-			{
-				liberation(s_etat_processus, s_objet);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_variable_non_definie;
-				return;
-			}
-
-			((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante]).variable_verrouillee = d_vrai;
+			(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_verrouillee = d_vrai;
 
 			l_element_courant = (*l_element_courant).suivant;
 		}
@@ -776,7 +718,8 @@ instruction_poke(struct_processus *s_eta
 			return;
 		}
 
-		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;
@@ -807,11 +750,30 @@ instruction_poke(struct_processus *s_eta
 					// figure !
 
 					action.sa_handler = SIG_IGN;
-					action.sa_flags = SA_ONSTACK;
+					action.sa_flags = 0;
+
+#					ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#					else
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
+					if (pthread_mutex_lock(&mutex_sigaction) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
 
 					if (sigaction(SIGPIPE, &action, &registre) != 0)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+						pthread_mutex_unlock(&mutex_sigaction);
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
 
 						(*s_etat_processus).erreur_systeme = d_es_signal;
 						return;
@@ -821,9 +783,9 @@ instruction_poke(struct_processus *s_eta
 					// débloquer les instructions de type WF* pour les
 					// lectures bloquantes.
 
-					if (kill((*(*((struct_processus_fils *)
+					if (envoi_signal_processus((*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet))
-							.thread).pid, SIGINJECT) != 0)
+							.thread).pid, rpl_siginject, d_faux) != 0)
 					{
 						// Le processus fils peut s'être terminé.
 						break;
@@ -841,50 +803,24 @@ instruction_poke(struct_processus *s_eta
 
 						if ((*s_etat_processus).erreur_systeme != d_es)
 						{
-							pthread_mutex_unlock(&((*s_etat_processus).mutex));
+							pthread_mutex_unlock(&mutex_sigaction);
+							pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_pile_processus));
 							return;
 						}
 					}
 
-#					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
-#					else
-					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
-#					endif
-
 					while((longueur_ecriture = write_atomic(s_etat_processus,
 							(*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread)
 							.pipe_nombre_injections[1], "-",
 							sizeof(unsigned char))) != sizeof(unsigned char))
 					{
-#						ifndef SEMAPHORES_NOMMES
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
-#						else
-						while(sem_wait((*s_etat_processus)
-								.semaphore_fork) == -1)
-#						endif
-						{
-							if (errno != EINTR)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return;
-							}
-						}
-
 						if (longueur_ecriture == -1)
 						{
-							pthread_mutex_unlock(&((*s_etat_processus).mutex));
+							pthread_mutex_unlock(&mutex_sigaction);
+							pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_pile_processus));
 
 							liberation(s_etat_processus, s_objet_argument_1);
 							liberation(s_etat_processus, s_objet_argument_2);
@@ -911,6 +847,7 @@ instruction_poke(struct_processus *s_eta
 
 							if (sigaction(SIGPIPE, &registre, NULL) != 0)
 							{
+								pthread_mutex_unlock(&mutex_sigaction);
 								(*s_etat_processus).erreur_systeme =
 										d_es_signal;
 								return;
@@ -918,18 +855,6 @@ instruction_poke(struct_processus *s_eta
 
 							return;
 						}
-
-#						ifndef SEMAPHORES_NOMMES
-						if (sem_post(&((*s_etat_processus)
-								.semaphore_fork)) != 0)
-#						else
-						if (sem_post((*s_etat_processus)
-								.semaphore_fork) != 0)
-#						endif
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
 					}
 
 					if (ecriture_pipe(s_etat_processus,
@@ -946,19 +871,6 @@ instruction_poke(struct_processus *s_eta
 						}
 					}
 
-#					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#					endif
-					{
-						if (errno == EINTR)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
-					}
-
 					if (registre_stop == 0)
 					{
 						if ((*s_etat_processus)
@@ -979,12 +891,34 @@ instruction_poke(struct_processus *s_eta
 
 					if (sigaction(SIGPIPE, &registre, NULL) != 0)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+						pthread_mutex_unlock(&mutex_sigaction);
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
 
 						(*s_etat_processus).erreur_systeme = d_es_signal;
 						return;
 					}
 
+					if (pthread_mutex_unlock(&mutex_sigaction) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#					else
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#					endif
+					{
+						if (errno != EINTR)
+						{
+							(*s_etat_processus).erreur_systeme = d_es_processus;
+							return;
+						}
+					}
+
 					break;
 				}
 			}
@@ -1011,12 +945,63 @@ instruction_poke(struct_processus *s_eta
 					// de lecteur et on peut se prendre un SIGPIPE dans la
 					// figure !
 
+#					ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#					else
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
+					if (pthread_mutex_lock(&mutex_sigaction) != 0)
+					{
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
 					action.sa_handler = SIG_IGN;
-					action.sa_flags = SA_ONSTACK;
+					action.sa_flags = 0;
 
 					if (sigaction(SIGPIPE, &action, &registre) != 0)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						pthread_mutex_unlock(&mutex_sigaction);
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
 
 						(*s_etat_processus).erreur_systeme = d_es_signal;
 						return;
@@ -1030,6 +1015,23 @@ instruction_poke(struct_processus *s_eta
 							(*(*l_element_courant).donnee).objet)).thread)
 							.mutex)) != 0)
 					{
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						pthread_mutex_unlock(&mutex_sigaction);
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
@@ -1038,9 +1040,10 @@ instruction_poke(struct_processus *s_eta
 							(*(*l_element_courant).donnee).objet)).thread)
 							.thread_actif == d_vrai)
 					{
-						if (pthread_kill((*(*((struct_processus_fils *)
+						if (envoi_signal_thread(NULL,
+								(*(*((struct_processus_fils *)
 								(*(*l_element_courant).donnee).objet)).thread)
-								.tid, SIGINJECT) != 0)
+								.tid, rpl_siginject) != 0)
 						{
 							// Le processus fils peut s'être terminé.
 
@@ -1049,6 +1052,23 @@ instruction_poke(struct_processus *s_eta
 									(*(*l_element_courant).donnee).objet))
 									.thread).mutex)) != 0)
 							{
+#								ifndef SEMAPHORES_NOMMES
+									while(sem_wait(&((*s_etat_processus)
+											.semaphore_fork)) != 0)
+#								else
+									while(sem_wait((*s_etat_processus)
+											.semaphore_fork) != 0)
+#								endif
+								{
+									if (errno != EINTR)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es_processus;
+										return;
+									}
+								}
+
+								pthread_mutex_unlock(&mutex_sigaction);
 								(*s_etat_processus).erreur_systeme =
 										d_es_processus;
 								return;
@@ -1064,6 +1084,23 @@ instruction_poke(struct_processus *s_eta
 								(*(*l_element_courant).donnee).objet))
 								.thread).mutex)) != 0)
 						{
+#							ifndef SEMAPHORES_NOMMES
+								while(sem_wait(&((*s_etat_processus)
+										.semaphore_fork)) != 0)
+#							else
+								while(sem_wait((*s_etat_processus)
+										.semaphore_fork) != 0)
+#							endif
+							{
+								if (errno != EINTR)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_processus;
+									return;
+								}
+							}
+
+							pthread_mutex_unlock(&mutex_sigaction);
 							(*s_etat_processus).erreur_systeme = d_es_processus;
 							return;
 						}
@@ -1075,6 +1112,23 @@ instruction_poke(struct_processus *s_eta
 							(*(*l_element_courant).donnee).objet)).thread)
 							.mutex)) != 0)
 					{
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						pthread_mutex_unlock(&mutex_sigaction);
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
@@ -1091,46 +1145,39 @@ instruction_poke(struct_processus *s_eta
 
 						if ((*s_etat_processus).erreur_systeme != d_es)
 						{
-							pthread_mutex_unlock(&((*s_etat_processus).mutex));
+#							ifndef SEMAPHORES_NOMMES
+								while(sem_wait(&((*s_etat_processus)
+										.semaphore_fork)) != 0)
+#							else
+								while(sem_wait((*s_etat_processus)
+										.semaphore_fork) != 0)
+#							endif
+							{
+								if (errno != EINTR)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_processus;
+									return;
+								}
+							}
+
+							pthread_mutex_unlock(&mutex_sigaction);
+							pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_pile_processus));
 							return;
 						}
 					}
 
-#					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-#					else
-					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-#					endif
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
-
 					while((longueur_ecriture = write_atomic(s_etat_processus,
 							(*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread)
 							.pipe_nombre_injections[1], "-",
 							sizeof(unsigned char))) != sizeof(unsigned char))
 					{
-#						ifndef SEMAPHORES_NOMMES
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
-#						else
-						while(sem_wait((*s_etat_processus)
-								.semaphore_fork) == -1)
-#						endif
-						{
-							if (errno != EINTR)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return;
-							}
-						}
-
 						if (longueur_ecriture == -1)
 						{
-							pthread_mutex_unlock(&((*s_etat_processus).mutex));
+							pthread_mutex_unlock(&((*s_etat_processus)
+									.mutex_pile_processus));
 
 							liberation(s_etat_processus, s_objet_argument_1);
 							liberation(s_etat_processus, s_objet_argument_2);
@@ -1157,23 +1204,45 @@ instruction_poke(struct_processus *s_eta
 
 							if (sigaction(SIGPIPE, &registre, NULL) != 0)
 							{
+#								ifndef SEMAPHORES_NOMMES
+									while(sem_wait(&((*s_etat_processus)
+											.semaphore_fork)) != 0)
+#								else
+									while(sem_wait((*s_etat_processus)
+											.semaphore_fork) != 0)
+#								endif
+								{
+									if (errno != EINTR)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es_processus;
+										return;
+									}
+								}
+
+								pthread_mutex_unlock(&mutex_sigaction);
 								(*s_etat_processus).erreur_systeme =
 										d_es_signal;
 								return;
 							}
 
-							return;
-						}
+#							ifndef SEMAPHORES_NOMMES
+								while(sem_wait(&((*s_etat_processus)
+										.semaphore_fork)) != 0)
+#							else
+								while(sem_wait((*s_etat_processus)
+										.semaphore_fork) != 0)
+#							endif
+							{
+								if (errno != EINTR)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_processus;
+									return;
+								}
+							}
 
-#						ifndef SEMAPHORES_NOMMES
-						if (sem_post(&((*s_etat_processus)
-								.semaphore_fork)) != 0)
-#						else
-						if (sem_post((*s_etat_processus)
-								.semaphore_fork) != 0)
-#						endif
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
+							pthread_mutex_unlock(&mutex_sigaction);
 							return;
 						}
 					}
@@ -1192,21 +1261,6 @@ instruction_poke(struct_processus *s_eta
 						}
 					}
 
-#					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus)
-							.semaphore_fork)) == -1)
-#					else
-					while(sem_wait((*s_etat_processus)
-							.semaphore_fork) == -1)
-#					endif
-					{
-						if (errno != EINTR)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
-					}
-
 					if (registre_stop == 0)
 					{
 						if ((*s_etat_processus)
@@ -1227,12 +1281,66 @@ instruction_poke(struct_processus *s_eta
 
 					if (sigaction(SIGPIPE, &registre, NULL) != 0)
 					{
-						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						pthread_mutex_unlock(&mutex_sigaction);
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
 
 						(*s_etat_processus).erreur_systeme = d_es_signal;
 						return;
 					}
 
+					if (pthread_mutex_unlock(&mutex_sigaction) != 0)
+					{
+#						ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#						else
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#					else
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#					endif
+					{
+						if (errno != EINTR)
+						{
+							(*s_etat_processus).erreur_systeme = d_es_processus;
+							return;
+						}
+					}
+
 					break;
 				}
 			}
@@ -1240,7 +1348,8 @@ instruction_poke(struct_processus *s_eta
 			l_element_courant = (*l_element_courant).suivant;
 		}
 
-		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;
@@ -1342,76 +1451,41 @@ instruction_private(struct_processus *s_
 			return;
 		}
 
-		if (pthread_mutex_lock(&((*(*s_etat_processus)
-				.s_liste_variables_partagees).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
-
 		if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
-				(*s_objet).objet)).nom), ((*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante])
-				.variable_partagee, ((*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante]).origine)
-				== d_faux)
+				(*s_objet).objet)).nom), (*(*s_etat_processus)
+				.pointeur_variable_courante).variable_partagee,
+				(*(*s_etat_processus).pointeur_variable_courante).origine)
+				== NULL)
 		{
-			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			liberation(s_etat_processus, s_objet);
 
 			(*s_etat_processus).erreur_systeme = d_es;
 			return;
 		}
 
-		(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante].objet =
-				(*(*s_etat_processus).s_liste_variables_partagees).table
-				[(*(*s_etat_processus).s_liste_variables_partagees)
-				.position_variable].objet;
-		(*(*s_etat_processus).s_liste_variables_partagees).table
-				[(*(*s_etat_processus).s_liste_variables_partagees)
-				.position_variable].objet = NULL;
+		(*(*s_etat_processus).pointeur_variable_courante).objet =
+				(*(*s_etat_processus).pointeur_variable_partagee_courante)
+				.objet;
+		(*(*s_etat_processus).pointeur_variable_partagee_courante).objet = NULL;
 
 		if (retrait_variable_partagee(s_etat_processus,
 				(*((struct_nom *) (*s_objet).objet)).nom,
-				(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante].variable_partagee) == d_erreur)
+				(*(*s_etat_processus).pointeur_variable_courante)
+				.variable_partagee) == d_erreur)
 		{
-			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			liberation(s_etat_processus, s_objet);
 			return;
 		}
 
-		if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante].origine == 'P')
+		if ((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].variable_partagee.adresse = 0;
+			(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee.adresse = 0;
 		}
 		else
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].variable_partagee.pointeur
-					= NULL;
-		}
-
-		if (pthread_mutex_unlock(&((*(*s_etat_processus)
-				.s_liste_variables_partagees).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
+			(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee.pointeur = NULL;
 		}
 	}
 	else if ((*s_objet).type == LST)
@@ -1439,28 +1513,12 @@ instruction_private(struct_processus *s_
 				return;
 			}
 
-			if (pthread_mutex_lock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
-					(*s_objet).objet)).nom), ((*s_etat_processus)
-					.s_liste_variables[(*s_etat_processus)
-					.position_variable_courante]).variable_partagee,
-					((*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]).origine)
-					== d_faux)
+					(*s_objet).objet)).nom), (*(*s_etat_processus)
+					.pointeur_variable_courante).variable_partagee,
+					(*(*s_etat_processus).pointeur_variable_courante).origine)
+					== NULL)
 			{
-				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-
 				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).erreur_systeme = d_es;
@@ -1469,52 +1527,33 @@ instruction_private(struct_processus *s_
 				return;
 			}
 
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet =
-					(*(*s_etat_processus).s_liste_variables_partagees).table
-					[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet;
-			(*(*s_etat_processus).s_liste_variables_partagees).table
-					[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet = NULL;
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					(*(*s_etat_processus).pointeur_variable_partagee_courante)
+					.objet;
+			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet
+					= NULL;
 
-			if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].origine == 'P')
+			if ((*(*s_etat_processus).pointeur_variable_courante).origine
+					== 'P')
 			{
-				(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-						.position_variable_courante].variable_partagee.adresse
-						= 0;
+				(*(*s_etat_processus).pointeur_variable_courante)
+						.variable_partagee.adresse = 0;
 			}
 			else
 			{
-				(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-						.position_variable_courante].variable_partagee.pointeur
-						= NULL;
+				(*(*s_etat_processus).pointeur_variable_courante)
+						.variable_partagee.pointeur = NULL;
 			}
 
 			if (retrait_variable_partagee(s_etat_processus,
 					(*((struct_nom *) (*s_objet).objet)).nom,
-					(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].variable_statique) == d_erreur)
+					(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_statique) == d_erreur)
 			{
-				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-
 				liberation(s_etat_processus, s_objet);
 				return;
 			}
 
-			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			l_element_courant = (*l_element_courant).suivant;
 		}
 	}
@@ -1800,6 +1839,8 @@ instruction_procid(struct_processus *s_e
 			.tid = pthread_self();
 	(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
 			.processus_detache = (*s_etat_processus).processus_detache;
+	(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
+			.argument = NULL;
 
 	pthread_mutexattr_init(&attributs_mutex);
 	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
@@ -1807,6 +1848,13 @@ instruction_procid(struct_processus *s_e
 			(*s_objet).objet)).thread).mutex), &attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&((*(*((struct_processus_fils *)
+			(*s_objet).objet)).thread).mutex_nombre_references),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
 	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 			s_objet) == d_erreur)
 	{