--- rpl/src/evaluation.c	2013/04/17 13:53:17	1.77
+++ rpl/src/evaluation.c	2013/04/23 21:26:01	1.78
@@ -6721,6 +6721,359 @@ evaluation(struct_processus *s_etat_proc
 								}
 
 								depilement_pile_systeme(s_etat_processus);
+
+								if ((((*s_etat_processus).erreur_execution !=
+										d_ex) || ((*s_etat_processus)
+										.erreur_systeme != d_es)) &&
+										((*s_etat_processus).arret_si_exception
+										== d_faux))
+								{
+									// Reprise sur erreur.
+
+//==============================================================================
+//  Réindentation
+//==============================================================================
+
+			drapeau_then = d_faux;
+
+			while(drapeau_then == d_faux)
+			{
+				l_registre_atome = l_element_courant;
+				l_element_courant = (*l_element_courant).suivant;
+
+				if (l_element_courant == NULL)
+				{
+					/*
+					 * La fin de l'expression est atteinte,
+					 * le sequenceur reprend la main.
+					 */
+
+					if (presence_egalite == d_vrai)
+					{
+						liberation(s_etat_processus, s_objet_evalue);
+					}
+
+					(*s_etat_processus).mode_execution_programme =
+							registre_mode_execution_programme;
+					return(d_absence_erreur);
+				}
+
+				if ((*(*l_element_courant).donnee).type == FCT)
+				{
+					(*s_etat_processus).instruction_courante =
+							(*((struct_fonction *)
+							(*(*l_element_courant).donnee)
+							.objet)).nom_fonction;
+
+					if (recherche_variable(s_etat_processus,
+							(*s_etat_processus).instruction_courante) == d_faux)
+					{
+						(*s_etat_processus).erreur_systeme = d_es;
+						fonction = (*((struct_fonction *)
+								(*(*l_element_courant).donnee)
+								.objet)).fonction;
+
+						/*
+						 * Traitement de la pile système par les
+						 * différentes instructions.
+						 */
+
+						if (TEST(instruction_if) ||
+								TEST(instruction_iferr) ||
+								TEST(instruction_do) ||
+								TEST(instruction_while) ||
+								TEST(instruction_for) ||
+								TEST(instruction_forall) ||
+								TEST(instruction_start) ||
+								TEST(instruction_select) ||
+								TEST(instruction_case) ||
+								TEST(instruction_critical) ||
+								TEST(vers_niveau_superieur))
+						{
+							if (TEST(vers_niveau_superieur))
+							{
+								registre_exception = (*s_etat_processus)
+									.exception;
+								registre_erreur_execution = (*s_etat_processus)
+									.erreur_execution;
+
+								analyse(s_etat_processus,
+									   	vers_niveau_superieur);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								(*s_etat_processus).exception
+										= registre_exception;
+								(*s_etat_processus).erreur_execution =
+									registre_erreur_execution;
+							}
+							else if (TEST(instruction_for) ||
+									TEST(instruction_forall) ||
+									TEST(instruction_start))
+							{
+								empilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								(*(*s_etat_processus).l_base_pile_systeme)
+										.type_cloture = 'L';
+							}
+							else
+							{
+								empilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
+						else if (TEST(instruction_end) ||
+								TEST(instruction_next) ||
+								TEST(instruction_step) ||
+								TEST(vers_niveau_inferieur))
+						{
+							if (TEST(vers_niveau_inferieur))
+							{
+								registre_exception = (*s_etat_processus)
+										.exception;
+								registre_erreur_execution = (*s_etat_processus)
+										.erreur_execution;
+
+								analyse(s_etat_processus,
+										vers_niveau_inferieur);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+											s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								(*s_etat_processus).exception
+										= registre_exception;
+								(*s_etat_processus).erreur_execution =
+										registre_erreur_execution;
+							}
+							else if ((TEST(instruction_next) ||
+									TEST(instruction_step)) &&
+									((*(*s_etat_processus)
+									.l_base_pile_systeme)
+									.type_cloture != 'L'))
+							{
+								/*
+								 * Libération des compteurs
+								 * de boucle
+								 */
+
+								presence_compteur = (((*(*s_etat_processus)
+									.l_base_pile_systeme).type_cloture == 'F')
+									|| ((*(*s_etat_processus)
+									.l_base_pile_systeme).type_cloture == 'A'))
+									? d_vrai : d_faux;
+
+								if (((*(*s_etat_processus).l_base_pile_systeme)
+									.type_cloture != 'S') && (presence_compteur
+									== d_faux))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_erreur_traitement_boucle;
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+											s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								if (presence_compteur == d_vrai)
+								{
+									if (recherche_variable(s_etat_processus,
+											(*(*s_etat_processus)
+											.l_base_pile_systeme).nom_variable)
+											== d_faux)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es;
+										(*s_etat_processus).erreur_execution =
+												d_ex_erreur_traitement_boucle;
+
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante
+												= instruction_courante;
+										return(d_erreur);
+									}
+
+									if ((*(*s_etat_processus)
+											.pointeur_variable_courante)
+											.objet == NULL)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es;
+										(*s_etat_processus).erreur_execution =
+												d_ex_variable_partagee;
+
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante
+												= instruction_courante;
+										return(d_erreur);
+									}
+
+									(*s_etat_processus)
+											.niveau_courant--;
+
+									if (retrait_variables_par_niveau(
+											s_etat_processus) == d_erreur)
+									{
+										if (presence_egalite == d_vrai)
+										{
+											liberation(s_etat_processus,
+													s_objet_evalue);
+										}
+
+										(*s_etat_processus).instruction_courante												= instruction_courante;
+										return(d_erreur);
+									}
+								}
+
+								depilement_pile_systeme(s_etat_processus);
+							}
+							else
+							{
+								// Traitement spécifique pour
+								// la fin d'une section
+								// critique
+
+								if ((*s_etat_processus).l_base_pile_systeme
+										== NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_end_incoherent;
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								if ((*(*s_etat_processus).l_base_pile_systeme)
+										.type_cloture == 'Q')
+								{
+									if (pthread_mutex_unlock(
+											&mutex_sections_critiques) != 0)
+									{
+										(*s_etat_processus).erreur_systeme =
+												d_es_processus;
+
+										liberation(s_etat_processus,
+												s_objet_evalue);
+
+										(*s_etat_processus).instruction_courante												= instruction_courante;
+										return(d_erreur);
+									}
+
+									(*s_etat_processus).sections_critiques--;
+								}
+
+								depilement_pile_systeme(s_etat_processus);
+
+								if ((*s_etat_processus)
+										.erreur_systeme != d_es)
+								{
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
+						else if (TEST(instruction_then))
+						{
+							if ((*(*s_etat_processus).l_base_pile_systeme)
+									.clause == 'R')
+							{
+								(*(*s_etat_processus).l_base_pile_systeme)
+										.clause = 'X';
+								instruction_then(s_etat_processus);
+								drapeau_then = d_vrai;
+							}
+						}
+					}
+				}
+			}
+
+			(*s_etat_processus).expression_courante =
+					l_element_courant;
+			(*s_etat_processus).instruction_courante =
+					instruction_courante;
+
+			(*s_etat_processus).exception = d_ep;
+			(*s_etat_processus).erreur_execution = d_ex;
+
+//==============================================================================
+//  Fin de la réindentation
+//==============================================================================
+								}
 							}
 							else
 							{