--- rpl/src/evaluation.c	2013/03/05 16:26:46	1.71
+++ rpl/src/evaluation.c	2013/03/05 21:02:35	1.72
@@ -98,7 +98,6 @@ evaluation(struct_processus *s_etat_proc
 	unsigned long					niveau_initial;
 	unsigned long					nombre_termes;
 	unsigned long					registre_hauteur_pile_operationnelle;
-	unsigned long					registre_niveau_courant;
 	unsigned long					registre_position_courante;
 
 	void							(*fonction)();
@@ -5867,6 +5866,378 @@ evaluation(struct_processus *s_etat_proc
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
 
+							(*s_etat_processus).exception = d_ep;
+							(*s_etat_processus).erreur_execution = d_ex;
+
+							erreur_evaluation = d_erreur;
+						}
+						else
+						{
+							// On ne détruit pas les variables pour les inclure
+							// dans le fichier rpl-core.
+
+							(*s_etat_processus).gel_liste_variables = d_vrai;
+
+							registre_erreur_execution =
+									(*s_etat_processus).erreur_execution;
+							registre_exception =
+									(*s_etat_processus).exception;
+							registre_erreur_systeme =
+									(*s_etat_processus).erreur_systeme;
+
+							(*s_etat_processus).s_objet_errone = s_objet;
+							(*s_etat_processus).s_objet_erreur =
+									(*l_element_courant).donnee;
+
+							l_element_courant = (*l_element_courant).suivant;
+
+							while(l_element_courant != NULL)
+							{
+								if ((*(*l_element_courant).donnee).type == FCT)
+								{
+									(*s_etat_processus).instruction_courante =
+											(*((struct_fonction *)
+											(*(*l_element_courant).donnee)
+											.objet)).nom_fonction;
+									fonction = (*((struct_fonction *)
+											(*(*l_element_courant).donnee)
+											.objet)).fonction;
+
+									if (recherche_variable(s_etat_processus,
+											(*s_etat_processus)
+											.instruction_courante) == d_faux)
+									{
+										(*s_etat_processus).erreur_systeme
+												= d_es;
+
+										/*
+										 * Traitement de la pile système par les
+										 * différentes instructions.
+										 */
+
+										if (TEST(instruction_if) ||
+												TEST(instruction_iferr) ||
+												TEST(instruction_do) ||
+												TEST(instruction_while) ||
+												TEST(instruction_for) ||
+												TEST(instruction_forall) ||
+												TEST(instruction_start) ||
+												TEST(instruction_select) ||
+												TEST(instruction_case) ||
+												TEST(instruction_critical) ||
+												TEST(vers_niveau_superieur))
+										{
+											if (TEST(vers_niveau_superieur))
+											{
+												analyse(s_etat_processus,
+														vers_niveau_superieur);
+
+												if ((*s_etat_processus)
+														.erreur_systeme != d_es)
+												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											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(
+														s_etat_processus);
+
+												if ((*s_etat_processus)
+														.erreur_systeme != d_es)
+												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+										}
+										else if (TEST(instruction_end) ||
+												TEST(instruction_next) ||
+												TEST(instruction_step) ||
+												TEST(vers_niveau_inferieur))
+										{
+											if (TEST(vers_niveau_inferieur))
+											{
+												analyse(s_etat_processus,
+														vers_niveau_inferieur);
+
+												if ((*s_etat_processus)
+														.erreur_systeme != d_es)
+												{
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+											}
+											else if ((TEST(instruction_next) ||
+													TEST(instruction_step)) &&
+													((*(*s_etat_processus)
+													.l_base_pile_systeme)
+													.type_cloture != 'L'))
+											{
+												/*
+												 * Libération des compteurs
+												 * de boucle
+												 */
+
+												presence_compteur =
+													(((*(*s_etat_processus)
+													.l_base_pile_systeme)
+													.type_cloture == 'F') ||
+													((*(*s_etat_processus)
+													.l_base_pile_systeme)
+													.type_cloture == 'A'))
+													? d_vrai : d_faux;
+
+												if (((*(*s_etat_processus)
+													.l_base_pile_systeme)
+													.type_cloture != 'S') &&
+													(presence_compteur ==
+													d_faux))
+												{
+													(*s_etat_processus)
+												.erreur_execution =
+												d_ex_erreur_traitement_boucle;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if (presence_compteur == d_vrai)
+												{
+													if (recherche_variable(
+														s_etat_processus,
+														(*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.nom_variable) ==
+														d_faux)
+													{
+														(*s_etat_processus)
+												.erreur_systeme = d_es;
+														(*s_etat_processus)
+												.erreur_execution =
+												d_ex_erreur_traitement_boucle;
+
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+
+													if ((*(*s_etat_processus)
+													.pointeur_variable_courante)
+													.objet == NULL)
+													{
+														(*s_etat_processus)
+														.erreur_systeme = d_es;
+														(*s_etat_processus)
+														.erreur_execution =
+														d_ex_variable_partagee;
+
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+
+													(*s_etat_processus)
+														.niveau_courant--;
+
+													if (
+												retrait_variables_par_niveau(
+												s_etat_processus) == d_erreur)
+													{
+														if (presence_egalite ==
+																d_vrai)
+														{
+															liberation(
+															s_etat_processus,
+															s_objet_evalue);
+														}
+
+														(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+														return(d_erreur);
+													}
+												}
+
+												depilement_pile_systeme(
+														s_etat_processus);
+											}
+											else
+											{
+												// Traitement spécifique pour la
+												// fin d'une section critique
+
+												if ((*s_etat_processus)
+														.l_base_pile_systeme ==
+														NULL)
+												{
+													(*s_etat_processus)
+														.erreur_systeme =
+														d_es_end_incoherent;
+
+													if (presence_egalite ==
+															d_vrai)
+													{
+														liberation(
+															s_etat_processus,
+															s_objet_evalue);
+													}
+
+													(*s_etat_processus)
+														.instruction_courante =
+														instruction_courante;
+													return(d_erreur);
+												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.type_cloture == 'Q')
+												{
+													if (pthread_mutex_unlock(
+													&mutex_sections_critiques)
+													!= 0)
+													{
+														(*s_etat_processus)
+														.erreur_systeme =
+														d_es_processus;
+
+														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);
+
+												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);
+												}
+											}
+										}
+									}
+								}
+
+								l_element_courant =
+										(*l_element_courant).suivant;
+							}
+
+							(*s_etat_processus).mode_execution_programme =
+									registre_mode_execution_programme;
+							(*s_etat_processus).instruction_courante =
+									instruction_courante;
 							if (presence_egalite == d_vrai)
 							{
 								liberation(s_etat_processus, s_objet_evalue);