--- rpl/src/evaluation.c	2011/07/25 07:44:53	1.45
+++ rpl/src/evaluation.c	2012/09/30 20:46:46	1.58
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.2
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.10
+  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;
@@ -822,8 +823,8 @@ evaluation(struct_processus *s_etat_proc
 						if ((*s_etat_processus).var_volatile_processus_pere
 								== 0)
 						{
-							kill((*s_etat_processus)
-									.pid_processus_pere, SIGALRM);
+							envoi_signal_processus((*s_etat_processus)
+									.pid_processus_pere, rpl_sigalrm);
 						}
 						else
 						{
@@ -912,9 +913,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -932,6 +935,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -944,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(
@@ -987,6 +1026,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -999,8 +1046,183 @@ 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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour
+												// la fin d'une section
+												// critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme
+														== NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														liberation(
+														s_etat_processus,
+														s_objet_evalue);
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+
+													(*s_etat_processus)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -1084,9 +1306,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -1097,11 +1321,47 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if (TEST(instruction_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
 											{
@@ -1139,14 +1399,201 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if ((TEST(instruction_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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
 											}
 											else
 											{
+												// Traitement spécifique pour
+												// la fin d'une section
+												// critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme
+														== NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 											}
@@ -1237,9 +1684,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -1250,11 +1699,47 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if (TEST(instruction_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
 											{
@@ -1292,6 +1777,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -1306,8 +1799,186 @@ 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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour
+												// la fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme
+														== NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -1349,8 +2020,8 @@ evaluation(struct_processus *s_etat_proc
 							if ((*s_etat_processus)
 									.var_volatile_processus_pere == 0)
 							{
-								kill((*s_etat_processus)
-										.pid_processus_pere, SIGALRM);
+								envoi_signal_processus((*s_etat_processus)
+										.pid_processus_pere, rpl_sigalrm);
 							}
 							else
 							{
@@ -3146,8 +3817,8 @@ evaluation(struct_processus *s_etat_proc
 						if ((*s_etat_processus).var_volatile_processus_pere
 								== 0)
 						{
-							kill((*s_etat_processus)
-									.pid_processus_pere, SIGALRM);
+							envoi_signal_processus((*s_etat_processus)
+									.pid_processus_pere, rpl_sigalrm);
 						}
 						else
 						{
@@ -3235,9 +3906,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -3255,6 +3928,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -3267,6 +3948,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(
@@ -3310,6 +4019,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -3322,8 +4039,186 @@ 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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -3445,9 +4340,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -3458,11 +4355,47 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if (TEST(instruction_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
 											{
@@ -3500,14 +4433,200 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if ((TEST(instruction_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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -3595,9 +4714,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -3608,12 +4729,48 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if (TEST(instruction_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(
@@ -3650,14 +4807,200 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if ((TEST(instruction_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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -3699,8 +5042,8 @@ evaluation(struct_processus *s_etat_proc
 							if ((*s_etat_processus)
 									.var_volatile_processus_pere == 0)
 							{
-								kill((*s_etat_processus)
-										.pid_processus_pere, SIGALRM);
+								envoi_signal_processus((*s_etat_processus)
+										.pid_processus_pere, rpl_sigalrm);
 							}
 							else
 							{
@@ -3727,8 +5070,8 @@ evaluation(struct_processus *s_etat_proc
 						if ((*s_etat_processus).var_volatile_processus_pere
 								== 0)
 						{
-							kill((*s_etat_processus)
-									.pid_processus_pere, SIGALRM);
+							envoi_signal_processus((*s_etat_processus)
+									.pid_processus_pere, rpl_sigalrm);
 						}
 						else
 						{
@@ -3816,9 +5159,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -3836,6 +5181,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -3848,6 +5201,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(
@@ -3891,6 +5272,14 @@ evaluation(struct_processus *s_etat_proc
 												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;
@@ -3903,8 +5292,186 @@ 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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -4026,9 +5593,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -4039,11 +5608,47 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if (TEST(instruction_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
 											{
@@ -4081,14 +5686,200 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if ((TEST(instruction_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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -4176,9 +5967,11 @@ 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) ||
+												TEST(instruction_critical) ||
 												TEST(vers_niveau_superieur))
 										{
 											if (TEST(vers_niveau_superieur))
@@ -4189,12 +5982,48 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if (TEST(instruction_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(
@@ -4231,14 +6060,200 @@ evaluation(struct_processus *s_etat_proc
 												if ((*s_etat_processus)
 														.erreur_systeme != d_es)
 												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
 													(*s_etat_processus)
 														.instruction_courante =
 														instruction_courante;
 													return(d_erreur);
 												}
 											}
+											else if ((TEST(instruction_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_variable_par_niveau(
+													s_etat_processus) ==
+													d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
 											else
 											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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)
+														.sections_critiques--;
+												}
+
 												depilement_pile_systeme(
 														s_etat_processus);
 
@@ -4280,8 +6295,8 @@ evaluation(struct_processus *s_etat_proc
 							if ((*s_etat_processus)
 									.var_volatile_processus_pere == 0)
 							{
-								kill((*s_etat_processus)
-										.pid_processus_pere, SIGALRM);
+								envoi_signal_processus((*s_etat_processus)
+										.pid_processus_pere, rpl_sigalrm);
 							}
 							else
 							{
@@ -5111,21 +7126,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 =
@@ -5152,6 +7152,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)