--- rpl/src/evaluation.c	2012/09/15 12:57:09	1.56
+++ rpl/src/evaluation.c	2013/04/01 15:29:34	1.76
@@ -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.14
+  Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -48,9 +48,17 @@ 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;
+	logical1						presence_compteur;
 	logical1						presence_egalite;
 	logical1						presence_fonction;
 	logical1						presence_variable;
@@ -88,18 +96,9 @@ evaluation(struct_processus *s_etat_proc
 	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)();
 
@@ -180,14 +179,6 @@ evaluation(struct_processus *s_etat_proc
 					{
 						// 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);
-						}
-
 						presence_variable_partagee = d_faux;
 
 						if (recherche_variable_partagee(s_etat_processus,
@@ -195,17 +186,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;
 							}
@@ -213,17 +201,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;
@@ -234,8 +220,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;
@@ -247,14 +233,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
@@ -308,30 +286,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)
@@ -356,6 +324,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 =
@@ -408,17 +378,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);
 					}
 				}
@@ -452,7 +411,8 @@ evaluation(struct_processus *s_etat_proc
 						.niveau_courant = (*s_etat_processus)
 						.niveau_courant;
 
-				empilement_pile_systeme(s_etat_processus);
+				// ICI
+				//empilement_pile_systeme(s_etat_processus);
 
 				if (presence_variable_partagee == d_faux)
 				{
@@ -465,6 +425,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;
 
@@ -487,6 +449,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;
 
@@ -506,7 +470,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)
 				{
@@ -757,8 +720,6 @@ evaluation(struct_processus *s_etat_proc
 		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)
@@ -801,10 +762,30 @@ 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;
+
+						if (((*(*s_etat_processus).pointeur_variable_courante)
+								.origine == 'E') && ((*(*s_etat_processus)
+								.pointeur_variable_courante).niveau == 0))
+						{
+							(*s_etat_processus).evaluation_expression_compilee
+									= 'Y';
+						}
+						else
+						{
+							(*s_etat_processus).evaluation_expression_compilee
+									= 'N';
+						}
+
 						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 =
@@ -912,6 +893,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -953,6 +935,34 @@ evaluation(struct_processus *s_etat_proc
 													.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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -1016,6 +1026,128 @@ evaluation(struct_processus *s_etat_proc
 													.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
@@ -1065,6 +1197,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -1150,6 +1285,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -1178,6 +1314,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -1228,6 +1392,128 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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
@@ -1376,6 +1662,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -1404,6 +1691,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -1462,6 +1777,128 @@ evaluation(struct_processus *s_etat_proc
 													break;
 												}
 											}
+											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
@@ -1484,8 +1921,8 @@ evaluation(struct_processus *s_etat_proc
 													}
 
 													(*s_etat_processus)
-															.erreur_systeme =
-															d_es_processus;
+														.instruction_courante =
+														instruction_courante;
 													return(d_erreur);
 												}
 
@@ -1510,8 +1947,8 @@ evaluation(struct_processus *s_etat_proc
 														}
 
 														(*s_etat_processus)
-															.erreur_systeme =
-															d_es_processus;
+														.instruction_courante =
+														instruction_courante;
 														return(d_erreur);
 													}
 
@@ -1874,19 +2311,12 @@ 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.
 
@@ -1894,21 +2324,12 @@ evaluation(struct_processus *s_etat_proc
 
 							(*(*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
@@ -1938,8 +2359,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;
@@ -1972,8 +2393,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;
@@ -2006,8 +2427,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;
@@ -2046,8 +2467,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;
@@ -2089,8 +2510,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;
@@ -2126,8 +2547,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;
@@ -2169,8 +2590,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;
@@ -2232,7 +2653,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 =
@@ -2268,7 +2689,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 =
@@ -2305,7 +2726,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 =
@@ -2351,7 +2772,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 =
@@ -2387,8 +2808,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;
@@ -2430,8 +2851,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;
@@ -2473,8 +2894,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;
@@ -2536,7 +2957,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 =
@@ -2571,7 +2992,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 =
@@ -2624,7 +3045,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 =
@@ -2660,7 +3081,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 =
@@ -2703,7 +3124,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 =
@@ -2738,7 +3159,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 =
@@ -2779,7 +3200,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 =
@@ -2817,7 +3238,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 =
@@ -2874,7 +3295,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 =
@@ -2911,7 +3332,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 =
@@ -2953,7 +3374,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 =
@@ -2966,6 +3387,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);
@@ -2985,8 +3408,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)
@@ -3005,8 +3427,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;
@@ -3037,7 +3459,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 =
@@ -3050,6 +3472,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 =
@@ -3074,7 +3498,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 =
@@ -3109,8 +3533,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;
@@ -3140,7 +3564,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;
@@ -3172,7 +3597,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;
@@ -3195,7 +3621,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;
@@ -3446,6 +3873,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -3487,6 +3915,34 @@ evaluation(struct_processus *s_etat_proc
 													.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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -3550,6 +4006,128 @@ evaluation(struct_processus *s_etat_proc
 													.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
@@ -3602,6 +4180,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -3725,6 +4306,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -3753,6 +4335,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -3803,6 +4413,128 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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
@@ -3855,6 +4587,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -3944,6 +4679,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -3972,6 +4708,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -4022,6 +4786,128 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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
@@ -4074,6 +4960,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4234,6 +5123,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -4275,6 +5165,34 @@ evaluation(struct_processus *s_etat_proc
 													.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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -4338,6 +5256,128 @@ evaluation(struct_processus *s_etat_proc
 													.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
@@ -4390,6 +5430,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4513,6 +5556,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -4541,6 +5585,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -4591,6 +5663,128 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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
@@ -4643,6 +5837,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4732,6 +5929,7 @@ evaluation(struct_processus *s_etat_proc
 												TEST(instruction_do) ||
 												TEST(instruction_while) ||
 												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
 												TEST(instruction_start) ||
 												TEST(instruction_select) ||
 												TEST(instruction_case) ||
@@ -4760,6 +5958,34 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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)
+														.type_cloture = 'L';
+											}
 											else
 											{
 												empilement_pile_systeme(
@@ -4810,6 +6036,128 @@ evaluation(struct_processus *s_etat_proc
 													return(d_erreur);
 												}
 											}
+											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
@@ -4862,6 +6210,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4896,7 +6247,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);
@@ -4987,15 +6337,6 @@ evaluation(struct_processus *s_etat_proc
 							{
 								// 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);
-								}
-
 								presence_variable_partagee = d_faux;
 
 								if (recherche_variable_partagee(
@@ -5003,17 +6344,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;
 									}
@@ -5024,18 +6362,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 =
@@ -5051,8 +6386,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;
@@ -5064,16 +6399,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
@@ -5171,7 +6496,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)));
@@ -5179,7 +6504,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);
@@ -5216,6 +6541,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 =
@@ -5224,7 +6551,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';
@@ -5359,18 +6686,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)
@@ -5379,13 +6706,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);
@@ -5409,13 +6729,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;
 							}
 							else
 							{
@@ -5438,14 +6751,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);
@@ -5473,7 +6784,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);
@@ -5533,40 +6843,27 @@ evaluation(struct_processus *s_etat_proc
 								{
 									// 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);
-									}
-
 									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)
+											.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 =
@@ -5587,16 +6884,16 @@ 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
@@ -5736,21 +7033,6 @@ evaluation(struct_processus *s_etat_proc
 
 			// Traitement de l'instruction EXIT en mode interactif
 
-			if (l_element_courant != NULL)
-			{
-				l_element_courant = (*l_element_courant).suivant;
-			}
-			else
-			{
-				(*s_etat_processus).mode_execution_programme = 'Y';
-
-				if ((*s_etat_processus).niveau_courant == 1)
-				{
-					(*s_etat_processus).debug_programme = d_faux;
-					(*s_etat_processus).execution_pas_suivant = d_vrai;
-				}
-			}
-
 			if ((*s_etat_processus).traitement_cycle_exit != 'N')
 			{
 				registre_expression_courante =
@@ -5777,6 +7059,22 @@ evaluation(struct_processus *s_etat_proc
 				(*s_etat_processus).expression_courante =
 						registre_expression_courante;
 			}
+
+			if (l_element_courant != NULL)
+			{
+				l_element_courant = (*l_element_courant).suivant;
+			}
+			else
+			{
+				(*s_etat_processus).mode_execution_programme = 'Y';
+
+				if ((*s_etat_processus).niveau_courant == 1)
+				{
+					(*s_etat_processus).debug_programme = d_faux;
+					(*s_etat_processus).execution_pas_suivant = d_vrai;
+				}
+			}
+
 		}
 
 		if (niveau_initial < (*s_etat_processus).niveau_courant)
@@ -5788,8 +7086,17 @@ evaluation(struct_processus *s_etat_proc
 
 			(*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);
 			}
 		}
@@ -5798,78 +7105,35 @@ evaluation(struct_processus *s_etat_proc
 		 * 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
 		 */
 
-		if (pthread_mutex_lock(&((*(*s_etat_processus)
-				.s_liste_variables_partagees).mutex)) != 0)
+		if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
 		{
-			(*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 ((*(*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);
 		}