--- rpl/src/evaluation.c	2012/09/15 12:57:09	1.56
+++ rpl/src/evaluation.c	2012/10/07 08:18:35	1.61
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.10
+  RPL/2 (R) version 4.1.11
   Copyright (C) 1989-2012 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -51,6 +51,7 @@ evaluation(struct_processus *s_etat_proc
 
 	logical1						drapeau_then;
 	logical1						erreur_evaluation;
+	logical1						presence_compteur;
 	logical1						presence_egalite;
 	logical1						presence_fonction;
 	logical1						presence_variable;
@@ -912,6 +913,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 +955,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 +1046,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 +1217,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -1150,6 +1305,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 +1334,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 +1412,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 +1682,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 +1711,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 +1797,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 +1941,8 @@ evaluation(struct_processus *s_etat_proc
 													}
 
 													(*s_etat_processus)
-															.erreur_systeme =
-															d_es_processus;
+														.instruction_courante =
+														instruction_courante;
 													return(d_erreur);
 												}
 
@@ -1510,8 +1967,8 @@ evaluation(struct_processus *s_etat_proc
 														}
 
 														(*s_etat_processus)
-															.erreur_systeme =
-															d_es_processus;
+														.instruction_courante =
+														instruction_courante;
 														return(d_erreur);
 													}
 
@@ -3446,6 +3903,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 +3945,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 +4036,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 +4210,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -3725,6 +4336,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 +4365,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 +4443,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 +4617,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -3944,6 +4709,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 +4738,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 +4816,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 +4990,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4234,6 +5153,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 +5195,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 +5286,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 +5460,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4513,6 +5586,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 +5615,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 +5693,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 +5867,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -4732,6 +5959,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 +5988,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 +6066,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 +6240,9 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 														return(d_erreur);
 													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
 												}
 
 												depilement_pile_systeme(
@@ -5736,21 +7117,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 +7143,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 +7170,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,28 +7189,18 @@ 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);
 		}
 
 		/*