--- rpl/src/evaluation.c	2012/09/30 20:46:46	1.58
+++ rpl/src/evaluation.c	2016/09/27 15:29:32	1.103
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.10
-  Copyright (C) 1989-2012 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.26
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -31,14 +31,14 @@
 ================================================================================
   Evaluation d'une expression
 ================================================================================
-  Entrées :
+  Entrées :
     structure processus,
-	objet à évaluer (non libéré au retour de la routine)
+	objet à évaluer (non libéré au retour de la routine)
 	et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')
 --------------------------------------------------------------------------------
-  Sorties : objet évalué au niveau 1 de la pile
+  Sorties : objet évalué au niveau 1 de la pile
 --------------------------------------------------------------------------------
-  Effets de bord : néant
+  Effets de bord : néant
 ================================================================================
 */
 
@@ -48,6 +48,13 @@ evaluation(struct_processus *s_etat_proc
 {
 	integer8						i;
 	integer8						j;
+	integer8						k;
+	integer8						l;
+	integer8						niveau_initial;
+	integer8						nombre_termes;
+	integer8						registre_hauteur_pile_operationnelle;
+	integer8						registre_position_courante;
+
 
 	logical1						drapeau_then;
 	logical1						erreur_evaluation;
@@ -84,23 +91,13 @@ evaluation(struct_processus *s_etat_proc
 	unsigned char					registre_evaluation_forcee;
 	unsigned char					registre_instruction_valide;
 	unsigned char					registre_mode_execution_programme;
-	unsigned char					registre_retour_definition;
 	unsigned char					registre_test;
 	unsigned char					registre_test_2;
 	unsigned char					registre_type_evaluation;
 
-	unsigned int					registre_erreur_execution;
-	unsigned int					registre_erreur_systeme;
-	unsigned int					registre_exception;
-
-	unsigned long					k;
-	unsigned long					l;
-	unsigned long					n;
-	unsigned long					niveau_initial;
-	unsigned long					nombre_termes;
-	unsigned long					registre_hauteur_pile_operationnelle;
-	unsigned long					registre_niveau_courant;
-	unsigned long					registre_position_courante;
+	int								registre_erreur_execution;
+	int								registre_erreur_systeme;
+	int								registre_exception;
 
 	void							(*fonction)();
 
@@ -179,15 +176,7 @@ evaluation(struct_processus *s_etat_proc
 					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
-						// Variable partagée
-
-						if (pthread_mutex_lock(&((*(*s_etat_processus)
-								.s_liste_variables_partagees).mutex)) != 0)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_processus;
-							return(d_erreur);
-						}
+						// Variable partagée
 
 						presence_variable_partagee = d_faux;
 
@@ -196,17 +185,14 @@ evaluation(struct_processus *s_etat_proc
 								.pointeur_variable_courante).nom,
 								(*(*s_etat_processus)
 								.pointeur_variable_courante)
-								.variable_partagee, 'E') == d_vrai)
+								.variable_partagee, 'E') != NULL)
 						{
 							presence_variable = d_vrai;
 							presence_variable_partagee = d_vrai;
 
-							if ((*((*(*s_etat_processus)
-									.s_liste_variables_partagees).table
-									[(*(*s_etat_processus)
-									.s_liste_variables_partagees)
-									.position_variable].objet)).type
-									== ADR)
+							if ((*(*(*s_etat_processus)
+									.pointeur_variable_partagee_courante).objet)
+									.type == ADR)
 							{
 								presence_fonction = d_vrai;
 							}
@@ -214,17 +200,15 @@ evaluation(struct_processus *s_etat_proc
 							if ((s_copie_variable_partagee =
 									copie_objet(s_etat_processus,
 									(*(*s_etat_processus)
-									.s_liste_variables_partagees)
-									.table[(*(*s_etat_processus)
-									.s_liste_variables_partagees)
-									.position_variable].objet, 'P')) == NULL)
+									.pointeur_variable_partagee_courante).objet,
+									'P')) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -235,8 +219,8 @@ evaluation(struct_processus *s_etat_proc
 							}
 
 							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees).mutex))
-									!= 0)
+									.pointeur_variable_partagee_courante)
+									.mutex)) != 0)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_processus;
@@ -248,19 +232,11 @@ evaluation(struct_processus *s_etat_proc
 							(*s_etat_processus).erreur_systeme = d_es;
 							presence_variable = d_faux;
 							presence_variable_partagee = d_faux;
-
-							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees).mutex)) != 0)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return(d_erreur);
-							}
 						}
 					}
 					else
 					{
-						// Variable privée
+						// Variable privée
 
 						presence_variable = d_vrai;
 
@@ -309,30 +285,20 @@ evaluation(struct_processus *s_etat_proc
 				(*s_etat_processus).autorisation_empilement_programme = 'N';
 
 				(*(*s_etat_processus).l_base_pile_systeme)
-						.niveau_courant = (*s_etat_processus)
-						.niveau_courant;
+						.niveau_courant = (*s_etat_processus).niveau_courant;
 
 				if (presence_variable_partagee == d_faux)
 				{
 					(*s_etat_processus).position_courante =
-							(*((unsigned long *)
-							((*(*(*s_etat_processus).pointeur_variable_courante)
-							.objet).objet)));
+							(*((integer8 *) ((*(*(*s_etat_processus)
+							.pointeur_variable_courante).objet).objet)));
 				}
 				else
 				{
 					(*s_etat_processus).position_courante =
-							(*((unsigned long *) (*s_copie_variable_partagee)
+							(*((integer8 *) (*s_copie_variable_partagee)
 							.objet));
 					liberation(s_etat_processus, s_copie_variable_partagee);
-
-					if (pthread_mutex_unlock(&((*(*s_etat_processus)
-							.s_liste_variables_partagees).mutex)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_processus;
-						return(d_erreur);
-					}
 				}
 
 				if ((*s_etat_processus).profilage == d_vrai)
@@ -357,6 +323,8 @@ evaluation(struct_processus *s_etat_proc
 
 				if (sequenceur(s_etat_processus) == d_erreur)
 				{
+					depilement_pile_systeme(s_etat_processus);
+
 					(*s_etat_processus).evaluation_forcee =
 							registre_evaluation_forcee;
 					(*s_etat_processus).mode_execution_programme =
@@ -409,17 +377,6 @@ evaluation(struct_processus *s_etat_proc
 
 					if ((*s_etat_processus).erreur_systeme != d_es)
 					{
-						if (presence_variable_partagee == d_vrai)
-						{
-							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees).mutex)) != 0)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-								return(d_erreur);
-							}
-						}
-
 						return(d_erreur);
 					}
 				}
@@ -453,8 +410,6 @@ evaluation(struct_processus *s_etat_proc
 						.niveau_courant = (*s_etat_processus)
 						.niveau_courant;
 
-				empilement_pile_systeme(s_etat_processus);
-
 				if (presence_variable_partagee == d_faux)
 				{
 					if (evaluation(s_etat_processus, (*(*s_etat_processus)
@@ -466,6 +421,8 @@ evaluation(struct_processus *s_etat_proc
 							profilage(s_etat_processus, NULL);
 						}
 
+						depilement_pile_systeme(s_etat_processus);
+
 						(*s_etat_processus).evaluation_expression_compilee =
 								registre_evaluation_expression_compilee;
 
@@ -488,6 +445,8 @@ evaluation(struct_processus *s_etat_proc
 							profilage(s_etat_processus, NULL);
 						}
 
+						depilement_pile_systeme(s_etat_processus);
+
 						(*s_etat_processus).evaluation_expression_compilee =
 								registre_evaluation_expression_compilee;
 
@@ -507,7 +466,6 @@ evaluation(struct_processus *s_etat_proc
 				}
 
 				depilement_pile_systeme(s_etat_processus);
-				depilement_pile_systeme(s_etat_processus);
 
 				if ((*s_etat_processus).erreur_systeme != d_es)
 				{
@@ -613,10 +571,10 @@ evaluation(struct_processus *s_etat_proc
 
 		if (presence_egalite == d_vrai)
 		{
-			// S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
-			// le signe '=' et en le remplaçant d'une part par SWAP DROP
-			// et d'autre part par DROP. On évalue la première puis la
-			// seconde normalement avant de reconstituer le tout à la fin
+			// S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
+			// le signe '=' et en le remplaçant d'une part par SWAP DROP
+			// et d'autre part par DROP. On évalue la première puis la
+			// seconde normalement avant de reconstituer le tout à la fin
 			// de la routine.
 
 			l_registre_pile_operationnelle = NULL;
@@ -675,8 +633,8 @@ evaluation(struct_processus *s_etat_proc
 				return(d_erreur);
 			}
 
-			// Récupération de l'objet au niveau 1 résultat de l'évaluation
-			// du premier membre de l'équation puis destruction de la pile.
+			// Récupération de l'objet au niveau 1 résultat de l'évaluation
+			// du premier membre de l'équation puis destruction de la pile.
 
 			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 					&s_objet_evalue) == d_erreur)
@@ -688,7 +646,7 @@ evaluation(struct_processus *s_etat_proc
 
 			instruction_clear(s_etat_processus);
 
-			// Régénération de la pile initiale
+			// Régénération de la pile initiale
 
 			while(depilement(s_etat_processus, &l_registre_pile_operationnelle,
 					&s_sous_objet) != d_erreur)
@@ -752,15 +710,9 @@ evaluation(struct_processus *s_etat_proc
 		}
 
 		/*
-		 * Exécution de la séquence d'instructions
+		 * Exécution de la séquence d'instructions
 		 */
 
-		registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
-				.retour_definition;
-		(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
-		(*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
-				s_objet;
-
 		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
 		autorisation_empilement_programme = (*s_etat_processus)
 				.autorisation_empilement_programme;
@@ -779,8 +731,8 @@ evaluation(struct_processus *s_etat_proc
 			if ((*(*l_element_courant).donnee).type == FCT)
 			{
 				/*
-				 * Tester la cohérence avec une variable pour récupérer les
-				 * données selon les indices passés en argument (tableaux,
+				 * Tester la cohérence avec une variable pour récupérer les
+				 * données selon les indices passés en argument (tableaux,
 				 * listes...).
 				 */
 
@@ -802,10 +754,20 @@ evaluation(struct_processus *s_etat_proc
 							((*s_etat_processus).erreur_systeme == d_es) &&
 							((*s_etat_processus).exception == d_ep))
 					{
+						registre_evaluation_expression_compilee =
+								(*s_etat_processus)
+								.evaluation_expression_compilee;
+
+						(*s_etat_processus).evaluation_expression_compilee
+								= 'Y';
+
 						analyse(s_etat_processus, (*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
 								.fonction);
 
+						(*s_etat_processus).evaluation_expression_compilee =
+								registre_evaluation_expression_compilee;
+
 						if (type_evaluation == 'I')
 						{
 							(*s_etat_processus).derniere_erreur_evaluation =
@@ -824,7 +786,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -904,8 +867,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1053,7 +1016,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1147,9 +1110,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -1171,7 +1133,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section
 												// critique
 
@@ -1297,8 +1259,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1420,7 +1382,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1514,9 +1476,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -1538,7 +1499,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section
 												// critique
 
@@ -1637,7 +1598,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -1675,8 +1636,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1806,7 +1767,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1900,9 +1861,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -1924,7 +1884,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -2021,7 +1981,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -2046,7 +2007,7 @@ evaluation(struct_processus *s_etat_proc
 					else
 					{
 						/*
-						 * Régénération de la fonction en notation algébrique
+						 * Régénération de la fonction en notation algébrique
 						 */
 
 						if ((s_objet_elementaire = (struct_objet *)
@@ -2232,7 +2193,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 
 						/*
-						 * Clôture de l'expression
+						 * Clôture de l'expression
 						 */
 
 						if (((*l_element_fonction).suivant =
@@ -2334,41 +2295,25 @@ evaluation(struct_processus *s_etat_proc
 					if ((*(*s_etat_processus).pointeur_variable_courante).objet
 							== NULL)
 					{
-						if (pthread_mutex_lock(&((*(*s_etat_processus)
-								.s_liste_variables_partagees).mutex)) != 0)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_processus;
-						}
-
 						if (recherche_variable_partagee(s_etat_processus,
 								(*(*s_etat_processus)
 								.pointeur_variable_courante).nom,
 								(*(*s_etat_processus)
 								.pointeur_variable_courante).variable_partagee,
-								'E') == d_vrai)
+								'E') != NULL)
 						{
-							// Une variable partagée existe.
+							// Une variable partagée existe.
 
 							presence_variable_partagee = d_vrai;
 
 							(*(*s_etat_processus).pointeur_variable_courante)
 									.objet = (*(*s_etat_processus)
-									.s_liste_variables_partagees).table
-									[(*(*s_etat_processus)
-									.s_liste_variables_partagees)
-									.position_variable].objet;
+									.pointeur_variable_partagee_courante)
+									.objet;
 						}
 						else
 						{
 							presence_variable_partagee = d_faux;
-
-							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees).mutex)) != 0)
-							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_processus;
-							}
 						}
 					}
 					else
@@ -2377,13 +2322,13 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche d'un élément dans un vecteur
+					 * Recherche d'un élément dans un vecteur
 					 */
 
 					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
-						// La variable partagée n'existe plus.
+						// La variable partagée n'existe plus.
 
 						free(s_objet_elementaire);
 
@@ -2398,8 +2343,8 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -2432,8 +2377,8 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -2466,8 +2411,8 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -2506,8 +2451,8 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -2549,8 +2494,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2586,8 +2531,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2629,8 +2574,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2667,7 +2612,7 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche d'un élément dans une matrice
+					 * Recherche d'un élément dans une matrice
 					 */
 
 					else if ((((*((*(*s_etat_processus)
@@ -2692,7 +2637,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -2728,7 +2673,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -2765,7 +2710,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -2811,7 +2756,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -2847,8 +2792,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2890,8 +2835,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2933,8 +2878,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -2975,7 +2920,7 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche de l'élément idoine dans la liste
+					 * Recherche de l'élément idoine dans la liste
 					 */
 
 					else if (((*((*(*s_etat_processus)
@@ -2996,7 +2941,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3031,7 +2976,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3084,7 +3029,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3120,7 +3065,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3139,10 +3084,90 @@ evaluation(struct_processus *s_etat_proc
 									instruction_courante;
 							return(d_erreur);
 						}
+
+						// Si l'objet élémentaire est un nom et que ce nom n'est
+						// pas un nom symbolique, il convient de l'évaluer.
+
+						if ((*s_objet_elementaire).type == NOM)
+						{
+							if (((*((struct_nom *) (*s_objet_elementaire)
+									.objet)).symbole == d_faux) ||
+									(type_evaluation == 'N'))
+							{
+								if (evaluation(s_etat_processus,
+										s_objet_elementaire, 'E') == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								liberation(s_etat_processus,
+										s_objet_elementaire);
+
+
+								if (depilement(s_etat_processus,
+										&((*s_etat_processus).l_base_pile),
+										&s_objet_elementaire) == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
 					}
 
 					/*
-					 * Recherche de l'élément idoine dans la table
+					 * Recherche de l'élément idoine dans la table
 					 */
 
 					else if (((*((*(*s_etat_processus)
@@ -3163,7 +3188,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3198,7 +3223,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3239,7 +3264,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3277,7 +3302,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3296,6 +3321,86 @@ evaluation(struct_processus *s_etat_proc
 									instruction_courante;
 							return(d_erreur);
 						}
+
+						// Si l'objet élémentaire est un nom et que ce nom n'est
+						// pas un nom symbolique, il convient de l'évaluer.
+
+						if ((*s_objet_elementaire).type == NOM)
+						{
+							if (((*((struct_nom *) (*s_objet_elementaire)
+									.objet)).symbole == d_faux) ||
+									(type_evaluation == 'N'))
+							{
+								if (evaluation(s_etat_processus,
+										s_objet_elementaire, 'E') == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								liberation(s_etat_processus,
+										s_objet_elementaire);
+
+
+								if (depilement(s_etat_processus,
+										&((*s_etat_processus).l_base_pile),
+										&s_objet_elementaire) == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
 					}
 					else if (((*((*(*s_etat_processus)
 							.pointeur_variable_courante).objet)).type == ALG) ||
@@ -3334,7 +3439,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3371,7 +3476,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3413,7 +3518,7 @@ evaluation(struct_processus *s_etat_proc
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3426,6 +3531,8 @@ evaluation(struct_processus *s_etat_proc
 								liberation(s_etat_processus, s_objet_evalue);
 							}
 
+							depilement_pile_systeme(s_etat_processus);
+
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
 							return(d_erreur);
@@ -3445,8 +3552,7 @@ evaluation(struct_processus *s_etat_proc
 								.niveau_courant;
 
 						(*s_etat_processus).position_courante =
-								(*((unsigned long *)
-								((*(*(*s_etat_processus)
+								(*((integer8 *) ((*(*(*s_etat_processus)
 								.pointeur_variable_courante).objet).objet)));
 
 						if ((*s_etat_processus).profilage == d_vrai)
@@ -3465,8 +3571,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -3497,7 +3603,7 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3510,6 +3616,8 @@ evaluation(struct_processus *s_etat_proc
 								liberation(s_etat_processus, s_objet_evalue);
 							}
 
+							depilement_pile_systeme(s_etat_processus);
+
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
 							(*s_etat_processus).mode_execution_programme =
@@ -3534,7 +3642,7 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees)
+										.pointeur_variable_partagee_courante)
 										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -3569,8 +3677,8 @@ evaluation(struct_processus *s_etat_proc
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
+										.pointeur_variable_partagee_courante)
+										.mutex)) != 0)
 								{
 									(*s_etat_processus).erreur_systeme =
 											d_es_processus;
@@ -3600,7 +3708,8 @@ evaluation(struct_processus *s_etat_proc
 									NULL;
 
 							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees) .mutex)) != 0)
+									.pointeur_variable_partagee_courante)
+									.mutex)) != 0)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_processus;
@@ -3632,7 +3741,8 @@ evaluation(struct_processus *s_etat_proc
 									NULL;
 
 							if (pthread_mutex_unlock(&((*(*s_etat_processus)
-									.s_liste_variables_partagees).mutex)) != 0)
+									.pointeur_variable_partagee_courante)
+									.mutex)) != 0)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_processus;
@@ -3655,7 +3765,8 @@ evaluation(struct_processus *s_etat_proc
 						 		.pointeur_variable_courante).objet = NULL;
 
 						if (pthread_mutex_unlock(&((*(*s_etat_processus)
-								.s_liste_variables_partagees).mutex)) != 0)
+								.pointeur_variable_partagee_courante).mutex))
+								!= 0)
 						{
 							(*s_etat_processus).erreur_systeme =
 									d_es_processus;
@@ -3707,7 +3818,7 @@ evaluation(struct_processus *s_etat_proc
 								.evaluation_expression_compilee;
 
 						(*s_etat_processus).evaluation_expression_compilee
-								= 'N';
+								= 'Y';
 
 						if (evaluation(s_etat_processus, (*l_element_courant)
 								.donnee, type_evaluation) == d_erreur)
@@ -3818,7 +3929,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -3897,8 +4009,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4046,7 +4158,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4140,9 +4252,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -4164,7 +4275,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -4250,6 +4361,8 @@ evaluation(struct_processus *s_etat_proc
 
 							do
 							{
+								l_element_courant = (*l_element_courant)
+										.suivant;
 								l_registre_atome = l_element_courant;
 
 								if (l_element_courant == NULL)
@@ -4289,9 +4402,6 @@ evaluation(struct_processus *s_etat_proc
 									drapeau_then = TEST(instruction_then)
 											? d_vrai : d_faux;
 								}
-
-								l_element_courant = (*l_element_courant)
-										.suivant;
 							} while(drapeau_then == d_faux);
 
 							(*s_etat_processus).expression_courante =
@@ -4331,8 +4441,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4454,7 +4564,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4548,9 +4658,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -4572,7 +4681,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -4667,7 +4776,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -4705,8 +4814,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4828,7 +4937,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4922,9 +5031,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -4946,7 +5054,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -5043,7 +5151,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -5071,7 +5180,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -5106,6 +5216,8 @@ evaluation(struct_processus *s_etat_proc
 
 							free(message);
 
+							l_registre_atome = l_element_courant;
+
 							while((*(*s_etat_processus).l_base_pile_systeme)
 									.clause != 'R')
 							{
@@ -5150,8 +5262,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -5299,7 +5411,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -5393,9 +5505,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -5417,7 +5528,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -5503,13 +5614,15 @@ evaluation(struct_processus *s_etat_proc
 
 							do
 							{
+								(*s_etat_processus).expression_courante =
+										l_registre_atome;
 								l_registre_atome = l_element_courant;
 
 								if (l_element_courant == NULL)
 								{
 									/*
 									 * La fin de l'expression est atteinte,
-									 * le séquenceur reprend la main.
+									 * le séquenceur reprend la main.
 									 */
 
 									if (presence_egalite == d_vrai)
@@ -5547,9 +5660,6 @@ evaluation(struct_processus *s_etat_proc
 										.suivant;
 							} while(drapeau_then == d_faux);
 
-							(*s_etat_processus).expression_courante =
-									l_registre_atome;
-
 							(*(*s_etat_processus).l_base_pile_systeme)
 									.clause = 'X';
 							instruction_then(s_etat_processus);
@@ -5584,8 +5694,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -5707,7 +5817,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -5801,9 +5911,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -5825,7 +5934,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -5920,7 +6029,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -5958,8 +6067,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -6081,7 +6190,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -6175,9 +6284,8 @@ evaluation(struct_processus *s_etat_proc
 														.niveau_courant--;
 
 													if (
-													retrait_variable_par_niveau(
-													s_etat_processus) ==
-													d_erreur)
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
 													{
 														if (presence_egalite ==
 																d_vrai)
@@ -6199,7 +6307,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -6286,7 +6394,6 @@ evaluation(struct_processus *s_etat_proc
 									registre_mode_execution_programme;
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
-
 							if (presence_egalite == d_vrai)
 							{
 								liberation(s_etat_processus, s_objet_evalue);
@@ -6296,7 +6403,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -6375,16 +6483,7 @@ evaluation(struct_processus *s_etat_proc
 							if ((*(*s_etat_processus)
 									.pointeur_variable_courante).objet == NULL)
 							{
-								// Variable partagée
-
-								if (pthread_mutex_lock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-									return(d_erreur);
-								}
+								// Variable partagée
 
 								presence_variable_partagee = d_faux;
 
@@ -6393,17 +6492,14 @@ evaluation(struct_processus *s_etat_proc
 										.pointeur_variable_courante).nom,
 										(*(*s_etat_processus)
 										.pointeur_variable_courante)
-										.variable_partagee, 'E') == d_vrai)
+										.variable_partagee, 'E') != NULL)
 								{
 									presence_variable = d_vrai;
 									presence_variable_partagee = d_vrai;
 
-									if ((*((*(*s_etat_processus)
-											.s_liste_variables_partagees).table
-											[(*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.position_variable].objet)).type
-											== ADR)
+									if ((*(*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).objet).type == ADR)
 									{
 										presence_fonction = d_vrai;
 									}
@@ -6414,18 +6510,15 @@ evaluation(struct_processus *s_etat_proc
 											.objet)).symbole == d_faux))
 									{
 										if ((s_copie_variable_partagee =
-												copie_objet(s_etat_processus,
-												(*(*s_etat_processus)
-												.s_liste_variables_partagees)
-												.table[(*(*s_etat_processus)
-												.s_liste_variables_partagees)
-												.position_variable].objet, 'P'))
-												== NULL)
+											copie_objet(s_etat_processus,
+											(*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).objet, 'P')) == NULL)
 										{
 											if (pthread_mutex_unlock(
-													&((*(*s_etat_processus)
-													.s_liste_variables_partagees
-													).mutex)) != 0)
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 											{
 												(*s_etat_processus)
 														.erreur_systeme =
@@ -6441,8 +6534,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 									{
 										(*s_etat_processus).erreur_systeme =
 												d_es_processus;
@@ -6454,16 +6547,6 @@ evaluation(struct_processus *s_etat_proc
 									(*s_etat_processus).erreur_systeme = d_es;
 									presence_variable = d_faux;
 									presence_variable_partagee = d_faux;
-
-									if (pthread_mutex_unlock(
-											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
-									{
-										(*s_etat_processus).erreur_systeme =
-												d_es_processus;
-										return(d_erreur);
-									}
 								}
 							}
 							else
@@ -6491,8 +6574,8 @@ evaluation(struct_processus *s_etat_proc
 						if ((*((struct_nom *) (*(*l_element_courant).donnee)
 								.objet)).symbole == d_vrai)
 						{
-							// L'objet apparaît comme un symbole dans
-							// l'expression en cours d'évaluation. On se
+							// L'objet apparaît comme un symbole dans
+							// l'expression en cours d'évaluation. On se
 							// contente de l'empiler.
 
 							if ((s_sous_objet = copie_objet(s_etat_processus,
@@ -6561,7 +6644,7 @@ evaluation(struct_processus *s_etat_proc
 							if (presence_variable_partagee == d_faux)
 							{
 								(*s_etat_processus).position_courante =
-										(*((unsigned long *)
+										(*((integer8 *)
 										((*(*(*s_etat_processus)
 										.pointeur_variable_courante)
 										.objet).objet)));
@@ -6569,7 +6652,7 @@ evaluation(struct_processus *s_etat_proc
 							else
 							{
 								(*s_etat_processus).position_courante =
-										(*((unsigned long *)
+										(*((integer8 *)
 										(*s_copie_variable_partagee).objet));
 								liberation(s_etat_processus,
 										s_copie_variable_partagee);
@@ -6606,6 +6689,8 @@ evaluation(struct_processus *s_etat_proc
 											s_objet_evalue);
 								}
 
+								depilement_pile_systeme(s_etat_processus);
+
 								(*s_etat_processus).instruction_courante =
 										instruction_courante;
 								(*s_etat_processus).mode_execution_programme =
@@ -6614,7 +6699,7 @@ evaluation(struct_processus *s_etat_proc
 							}
 
 							(*s_etat_processus).evaluation_forcee =
-								registre_evaluation_forcee;
+									registre_evaluation_forcee;
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
 							(*s_etat_processus).mode_execution_programme = 'N';
@@ -6749,18 +6834,18 @@ evaluation(struct_processus *s_etat_proc
 									}
 								}
 
-								registre_niveau_courant = (*(*s_etat_processus)
-										.l_base_pile_systeme).niveau_courant;
-								registre_retour_definition =
-										(*(*s_etat_processus)
-										.l_base_pile_systeme).retour_definition;
+								empilement_pile_systeme(s_etat_processus);
 
 								(*(*s_etat_processus).l_base_pile_systeme)
 										.retour_definition = 'Y';
 								(*(*s_etat_processus).l_base_pile_systeme)
 										.niveau_courant = (*s_etat_processus)
 										.niveau_courant;
-								empilement_pile_systeme(s_etat_processus);
+								(*(*s_etat_processus).l_base_pile_systeme)
+										.pointeur_objet_retour =
+										l_element_courant;
+								(*(*s_etat_processus).l_base_pile_systeme)
+										.origine_routine_evaluation = 'Y';
 
 								if (evaluation(s_etat_processus,
 										(*(*s_etat_processus)
@@ -6769,13 +6854,6 @@ evaluation(struct_processus *s_etat_proc
 								{
 									depilement_pile_systeme(s_etat_processus);
 
-									(*(*s_etat_processus).l_base_pile_systeme)
-											.niveau_courant =
-											registre_niveau_courant;
-									(*(*s_etat_processus).l_base_pile_systeme)
-											.retour_definition =
-											registre_retour_definition;
-
 									if ((*s_etat_processus).profilage == d_vrai)
 									{
 										profilage(s_etat_processus, NULL);
@@ -6800,12 +6878,358 @@ evaluation(struct_processus *s_etat_proc
 
 								depilement_pile_systeme(s_etat_processus);
 
+								if ((((*s_etat_processus).erreur_execution !=
+										d_ex) || ((*s_etat_processus)
+										.erreur_systeme != d_es)) &&
+										((*s_etat_processus).arret_si_exception
+										== d_faux))
+								{
+									// Reprise sur erreur.
+
+//==============================================================================
+//  Réindentation
+//==============================================================================
+
+			drapeau_then = d_faux;
+
+			while(drapeau_then == d_faux)
+			{
+				l_registre_atome = l_element_courant;
+				l_element_courant = (*l_element_courant).suivant;
+
+				if (l_element_courant == NULL)
+				{
+					/*
+					 * La fin de l'expression est atteinte,
+					 * le sequenceur reprend la main.
+					 */
+
+					if (presence_egalite == d_vrai)
+					{
+						liberation(s_etat_processus, s_objet_evalue);
+					}
+
+					(*s_etat_processus).mode_execution_programme =
+							registre_mode_execution_programme;
+					return(d_absence_erreur);
+				}
+
+				if ((*(*l_element_courant).donnee).type == FCT)
+				{
+					(*s_etat_processus).instruction_courante =
+							(*((struct_fonction *)
+							(*(*l_element_courant).donnee)
+							.objet)).nom_fonction;
+
+					if (recherche_variable(s_etat_processus,
+							(*s_etat_processus).instruction_courante) == d_faux)
+					{
+						(*s_etat_processus).erreur_systeme = d_es;
+						fonction = (*((struct_fonction *)
+								(*(*l_element_courant).donnee)
+								.objet)).fonction;
+
+						/*
+						 * Traitement de la pile système par les
+						 * différentes instructions.
+						 */
+
+						if (TEST(instruction_if) ||
+								TEST(instruction_iferr) ||
+								TEST(instruction_do) ||
+								TEST(instruction_while) ||
+								TEST(instruction_for) ||
+								TEST(instruction_forall) ||
+								TEST(instruction_start) ||
+								TEST(instruction_select) ||
+								TEST(instruction_case) ||
+								TEST(instruction_critical) ||
+								TEST(vers_niveau_superieur))
+						{
+							if (TEST(vers_niveau_superieur))
+							{
+								registre_exception = (*s_etat_processus)
+									.exception;
+								registre_erreur_execution = (*s_etat_processus)
+									.erreur_execution;
+
+								analyse(s_etat_processus,
+									   	vers_niveau_superieur);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								(*s_etat_processus).exception
+										= registre_exception;
+								(*s_etat_processus).erreur_execution =
+									registre_erreur_execution;
+							}
+							else if (TEST(instruction_for) ||
+									TEST(instruction_forall) ||
+									TEST(instruction_start))
+							{
+								empilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
 								(*(*s_etat_processus).l_base_pile_systeme)
-										.niveau_courant =
-										registre_niveau_courant;
+										.type_cloture = 'L';
+							}
+							else
+							{
+								empilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
+						else if (TEST(instruction_end) ||
+								TEST(instruction_next) ||
+								TEST(instruction_step) ||
+								TEST(vers_niveau_inferieur))
+						{
+							if (TEST(vers_niveau_inferieur))
+							{
+								registre_exception = (*s_etat_processus)
+										.exception;
+								registre_erreur_execution = (*s_etat_processus)
+										.erreur_execution;
+
+								analyse(s_etat_processus,
+										vers_niveau_inferieur);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+											s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								(*s_etat_processus).exception
+										= registre_exception;
+								(*s_etat_processus).erreur_execution =
+										registre_erreur_execution;
+							}
+							else if ((TEST(instruction_next) ||
+									TEST(instruction_step)) &&
+									((*(*s_etat_processus)
+									.l_base_pile_systeme)
+									.type_cloture != 'L'))
+							{
+								/*
+								 * Libération des compteurs
+								 * de boucle
+								 */
+
+								presence_compteur = (((*(*s_etat_processus)
+									.l_base_pile_systeme).type_cloture == 'F')
+									|| ((*(*s_etat_processus)
+									.l_base_pile_systeme).type_cloture == 'A'))
+									? d_vrai : d_faux;
+
+								if (((*(*s_etat_processus).l_base_pile_systeme)
+									.type_cloture != 'S') && (presence_compteur
+									== d_faux))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_erreur_traitement_boucle;
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+											s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								if (presence_compteur == d_vrai)
+								{
+									if (recherche_variable(s_etat_processus,
+											(*(*s_etat_processus)
+											.l_base_pile_systeme).nom_variable)
+											== d_faux)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es;
+										(*s_etat_processus).erreur_execution =
+												d_ex_erreur_traitement_boucle;
+
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante
+												= instruction_courante;
+										return(d_erreur);
+									}
+
+									if ((*(*s_etat_processus)
+											.pointeur_variable_courante)
+											.objet == NULL)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es;
+										(*s_etat_processus).erreur_execution =
+												d_ex_variable_partagee;
+
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante
+												= instruction_courante;
+										return(d_erreur);
+									}
+
+									(*s_etat_processus)
+											.niveau_courant--;
+
+									if (retrait_variables_par_niveau(
+											s_etat_processus) == d_erreur)
+									{
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante												= instruction_courante;
+										return(d_erreur);
+									}
+								}
+
+								depilement_pile_systeme(s_etat_processus);
+							}
+							else
+							{
+								// Traitement spécifique pour
+								// la fin d'une section
+								// critique
+
+								if ((*s_etat_processus).l_base_pile_systeme
+										== NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_end_incoherent;
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								if ((*(*s_etat_processus).l_base_pile_systeme)
+										.type_cloture == 'Q')
+								{
+									if (pthread_mutex_unlock(
+											&mutex_sections_critiques) != 0)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es_processus;
+
+										liberation(s_etat_processus,
+												s_objet_evalue);
+
+										(*s_etat_processus).instruction_courante												= instruction_courante;
+										return(d_erreur);
+									}
+
+									(*s_etat_processus).sections_critiques--;
+								}
+
+								depilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus)
+										.erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
+						else if (TEST(instruction_then))
+						{
+							if ((*(*s_etat_processus).l_base_pile_systeme)
+									.clause == 'R')
+							{
 								(*(*s_etat_processus).l_base_pile_systeme)
-										.retour_definition =
-									   	registre_retour_definition;
+										.clause = 'X';
+								instruction_then(s_etat_processus);
+								drapeau_then = d_vrai;
+							}
+						}
+					}
+				}
+			}
+
+			(*s_etat_processus).expression_courante =
+					l_element_courant;
+			(*s_etat_processus).instruction_courante =
+					instruction_courante;
+
+			(*s_etat_processus).exception = d_ep;
+			(*s_etat_processus).erreur_execution = d_ex;
+
+//==============================================================================
+//  Fin de la réindentation
+//==============================================================================
+								}
 							}
 							else
 							{
@@ -6828,14 +7252,12 @@ evaluation(struct_processus *s_etat_proc
 								(*(*s_etat_processus).l_base_pile_systeme)
 										.niveau_courant = (*s_etat_processus)
 										.niveau_courant;
-								empilement_pile_systeme(s_etat_processus);
 
 								if (evaluation(s_etat_processus,
 										s_copie_variable_partagee,
 										type_evaluation) == d_erreur)
 								{
 									depilement_pile_systeme(s_etat_processus);
-									depilement_pile_systeme(s_etat_processus);
 
 									liberation(s_etat_processus,
 											s_copie_variable_partagee);
@@ -6863,7 +7285,6 @@ evaluation(struct_processus *s_etat_proc
 								}
 
 								depilement_pile_systeme(s_etat_processus);
-								depilement_pile_systeme(s_etat_processus);
 
 								liberation(s_etat_processus,
 										s_copie_variable_partagee);
@@ -6904,7 +7325,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 
 						/*
-						 * Vérification du drapeau symbole pour
+						 * Vérification du drapeau symbole pour
 						 * savoir si l'on met dans la pile le nom
 						 * ou le contenu de la variable.
 						 */
@@ -6921,17 +7342,7 @@ evaluation(struct_processus *s_etat_proc
 										.pointeur_variable_courante).objet
 										== NULL)
 								{
-									// Variable partagée
-
-									if (pthread_mutex_lock(
-											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
-									{
-										(*s_etat_processus).erreur_systeme =
-												d_es_processus;
-										return(d_erreur);
-									}
+									// Variable partagée
 
 									if (recherche_variable_partagee(
 											s_etat_processus,
@@ -6939,24 +7350,21 @@ evaluation(struct_processus *s_etat_proc
 											.pointeur_variable_courante).nom,
 											(*(*s_etat_processus)
 											.pointeur_variable_courante)
-											.variable_partagee, 'E') == d_vrai)
+											.variable_partagee, 'E') != NULL)
 									{
 										liberation(s_etat_processus,
 												s_objet_elementaire);
 
 										if ((s_objet_elementaire =
-												copie_objet(s_etat_processus,
-												(*(*s_etat_processus)
-												.s_liste_variables_partagees)
-												.table[(*(*s_etat_processus)
-												.s_liste_variables_partagees)
-												.position_variable].objet,
-												'P')) == NULL)
+											copie_objet(s_etat_processus,
+											(*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).objet, 'P')) == NULL)
 										{
 											if (pthread_mutex_unlock(
-													&((*(*s_etat_processus)
-													.s_liste_variables_partagees
-													).mutex)) != 0)
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
 											{
 												(*s_etat_processus)
 														.erreur_systeme =
@@ -6977,21 +7385,21 @@ evaluation(struct_processus *s_etat_proc
 													instruction_courante;
 											return(d_erreur);
 										}
-									}
 
-									if (pthread_mutex_unlock(
+										if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
-											.s_liste_variables_partagees)
-											.mutex)) != 0)
-									{
-										(*s_etat_processus).erreur_systeme =
-												d_es_processus;
-										return(d_erreur);
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+											return(d_erreur);
+										}
 									}
 								}
 								else
 								{
-									// Variable privée
+									// Variable privée
 
 									liberation(s_etat_processus,
 											s_objet_elementaire);
@@ -7075,8 +7483,8 @@ evaluation(struct_processus *s_etat_proc
 							((*s_etat_processus).erreur_execution != d_ex) ||
 							((*s_etat_processus).exception != d_ep))
 					{
-						// Il est anormal de récupérer ici une erreur
-						// d'exécution puisqu'on empile une constante
+						// Il est anormal de récupérer ici une erreur
+						// d'exécution puisqu'on empile une constante
 						// symbolique.
 
 						if (presence_egalite == d_vrai)
@@ -7173,100 +7581,66 @@ evaluation(struct_processus *s_etat_proc
 		if (niveau_initial < (*s_etat_processus).niveau_courant)
 		{
 			/*
-			 * Retrait des variables dans le cas où l'évaluation de
-			 * l'expression a été interrompue
+			 * Retrait des variables dans le cas où l'évaluation de
+			 * l'expression a été interrompue
 			 */
 
 			(*s_etat_processus).niveau_courant = niveau_initial;
 
-			if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
+			if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
 			{
+				if (presence_egalite == d_vrai)
+				{
+					liberation(s_etat_processus, s_objet_evalue);
+				}
+
+				(*s_etat_processus).instruction_courante =
+						instruction_courante;
+				(*s_etat_processus).mode_execution_programme =
+						registre_mode_execution_programme;
 				return(d_erreur);
 			}
 		}
 
 		/*
-		 * Retrait des variables statiques créées dans l'expression
+		 * Retrait des variables statiques créées dans l'expression
 		 */
 
-		for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
+		if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
 		{
-			if ((*s_etat_processus).s_liste_variables_statiques[n]
-					.niveau > (*s_etat_processus).niveau_courant)
+			if (presence_egalite == d_vrai)
 			{
-				if (retrait_variable_statique(s_etat_processus,
-						(*s_etat_processus).s_liste_variables_statiques[n].nom,
-						(*s_etat_processus).s_liste_variables_statiques[n]
-						.variable_statique) == d_erreur)
-				{
-					if (presence_egalite == d_vrai)
-					{
-						liberation(s_etat_processus, s_objet_evalue);
-					}
-
-					(*s_etat_processus).instruction_courante =
-							instruction_courante;
-					(*s_etat_processus).mode_execution_programme =
-							registre_mode_execution_programme;
-					return(d_erreur);
-				}
+				liberation(s_etat_processus, s_objet_evalue);
 			}
+
+			(*s_etat_processus).instruction_courante =
+					instruction_courante;
+			(*s_etat_processus).mode_execution_programme =
+					registre_mode_execution_programme;
+			return(d_erreur);
 		}
 
 		/*
-		 * Retrait des variables partagées créées dans l'expression
+		 * Retrait des variables partagées créées dans l'expression
 		 */
 
-		if (pthread_mutex_lock(&((*(*s_etat_processus)
-				.s_liste_variables_partagees).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return(d_erreur);
-		}
-
-		for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
-				.nombre_variables; n++)
+		if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
 		{
-			if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
-					.niveau > (*s_etat_processus).niveau_courant)
+			if (presence_egalite == d_vrai)
 			{
-				if (retrait_variable_partagee(s_etat_processus,
-						(*(*s_etat_processus).s_liste_variables_partagees)
-						.table[n].nom, (*(*s_etat_processus)
-						.s_liste_variables_partagees).table[n]
-						.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(d_erreur);
-					}
-
-					if (presence_egalite == d_vrai)
-					{
-						liberation(s_etat_processus, s_objet_evalue);
-					}
-
-					(*s_etat_processus).instruction_courante =
-							instruction_courante;
-					(*s_etat_processus).mode_execution_programme =
-							registre_mode_execution_programme;
-					return(d_erreur);
-				}
+				liberation(s_etat_processus, s_objet_evalue);
 			}
-		}
 
-		if (pthread_mutex_unlock(&((*(*s_etat_processus)
-				.s_liste_variables_partagees).mutex)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
+			(*s_etat_processus).instruction_courante =
+					instruction_courante;
+			(*s_etat_processus).mode_execution_programme =
+					registre_mode_execution_programme;
 			return(d_erreur);
 		}
 
 		if ((*s_etat_processus).var_volatile_requete_arret != 0)
 		{
-			// Restauration de la pile système
+			// Restauration de la pile système
 
 			while(pile_systeme_originelle !=
 					(*s_etat_processus).l_base_pile_systeme)
@@ -7277,7 +7651,7 @@ evaluation(struct_processus *s_etat_proc
 
 		if (presence_egalite == d_vrai)
 		{
-			// Ajout du membre évalué lors de la première passe
+			// Ajout du membre évalué lors de la première passe
 
 			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 					s_objet_evalue) == d_erreur)
@@ -7296,9 +7670,6 @@ evaluation(struct_processus *s_etat_proc
 				(*s_etat_processus).autorisation_empilement_programme =
 						autorisation_empilement_programme;
 				(*s_etat_processus).instruction_courante = instruction_courante;
-				(*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-						registre_retour_definition;
-
 				return(d_erreur);
 			}
 
@@ -7311,9 +7682,6 @@ evaluation(struct_processus *s_etat_proc
 				(*s_etat_processus).autorisation_empilement_programme =
 						autorisation_empilement_programme;
 				(*s_etat_processus).instruction_courante = instruction_courante;
-				(*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-						registre_retour_definition;
-
 				return(d_erreur);
 			}
 		}
@@ -7321,8 +7689,6 @@ evaluation(struct_processus *s_etat_proc
 		(*s_etat_processus).autorisation_empilement_programme =
 				autorisation_empilement_programme;
 		(*s_etat_processus).instruction_courante = instruction_courante;
-		(*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-				registre_retour_definition;
 	}
 	else if ((*s_objet).type == FCT)
 	{
@@ -7331,7 +7697,15 @@ evaluation(struct_processus *s_etat_proc
 
 		registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
 				? 'E' : 'N';
-		cf(s_etat_processus, 35);
+
+		if (type_evaluation == 'N')
+		{
+			cf(s_etat_processus, 35);
+		}
+		else
+		{
+			sf(s_etat_processus, 35);
+		}
 
 		analyse(s_etat_processus, (*((struct_fonction *)
 				(*s_objet).objet)).fonction);