--- rpl/src/evaluation.c	2010/04/07 13:45:02	1.10
+++ rpl/src/evaluation.c	2010/04/17 18:57:35	1.11
@@ -19,7 +19,7 @@
 ================================================================================
 */
 
-
+#define DEBUG_RETURN
 #include "rpl.conv.h"
 
 #define TEST(instruction) (fonction == instruction)
@@ -148,8 +148,9 @@ evaluation(struct_processus *s_etat_proc
 					if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
 							d_faux)
 					{
+uprintf("Paf !\n");
 						(*s_etat_processus).erreur_execution =
-								d_ex_manque_argument;
+								d_ex_nom_implicite;
 						return(d_erreur);
 					}
 				}
@@ -4013,7 +4014,7 @@ evaluation(struct_processus *s_etat_proc
 								{
 									/*
 									 * La fin de l'expression est atteinte,
-									 * le sequenceur reprend la main.
+									 * le séquenceur reprend la main.
 									 */
 
 									if (presence_egalite == d_vrai)
@@ -4392,20 +4393,489 @@ evaluation(struct_processus *s_etat_proc
 					if (recherche_variable(s_etat_processus, (*((struct_nom *)
 							(*s_objet_elementaire).objet)).nom) == d_faux)
 					{
+						(*s_etat_processus).erreur_systeme = d_es;
+						presence_variable = d_faux;
+
 						if ((*s_etat_processus).autorisation_nom_implicite
 								== 'N')
 						{
 							if ((*((struct_nom *) (*s_objet_elementaire).objet))
 									.symbole == d_faux)
 							{
-								(*s_etat_processus).erreur_systeme =
-										d_es_nom_implicite;
-								return(d_erreur);
+uprintf("Pif\n");
+								(*s_etat_processus).erreur_execution =
+										d_ex_nom_implicite;
+
+/*
+================================================================================
+  Reprise sur erreur
+  Réindentation du code
+================================================================================
+*/
+
+if ((*s_etat_processus).arret_si_exception == d_faux)
+{
+uprintf("(*s_etat_processus).arret_si_exception == d_faux\n");
+	/*
+	 * Reprise sur erreur
+	 */
+
+	if ((message = messages(s_etat_processus)) == NULL)
+	{
+		if (presence_egalite == d_vrai)
+		{
+			liberation(s_etat_processus,
+					s_objet_evalue);
+		}
+
+		(*s_etat_processus).instruction_courante =
+				instruction_courante;
+		return(d_erreur);
+	}
+
+	free(message);
+
+	while((*(*s_etat_processus).l_base_pile_systeme)
+			.clause != 'R')
+	{
+		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_start) ||
+						TEST(instruction_select) ||
+						TEST(instruction_case) ||
+						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)
+						{
+							(*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
+					{
+						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;
 
-						(*s_etat_processus).erreur_systeme = d_es;
-						presence_variable = d_faux;
+						analyse(s_etat_processus, vers_niveau_inferieur);
+
+						if ((*s_etat_processus).erreur_systeme != d_es)
+						{
+							(*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
+					{
+						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);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	(*s_etat_processus).instruction_courante = instruction_courante;
+	drapeau_then = d_faux;
+
+	do
+	{
+		l_registre_atome = l_element_courant;
+
+		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;
+			(*s_etat_processus).instruction_courante = instruction_courante;
+			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;
+			fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)
+					.objet)).fonction;
+			(*s_etat_processus).instruction_courante = instruction_courante;
+
+			drapeau_then = TEST(instruction_then) ? d_vrai : d_faux;
+		}
+
+		l_element_courant = (*l_element_courant) .suivant;
+	} while(drapeau_then == d_faux);
+
+	(*s_etat_processus).expression_courante = l_registre_atome;
+
+	(*(*s_etat_processus).l_base_pile_systeme).clause = 'X';
+	instruction_then(s_etat_processus);
+
+	(*s_etat_processus).exception = d_ep;
+	(*s_etat_processus).erreur_execution = d_ex;
+}
+else if ((*s_etat_processus).mode_evaluation_expression == 'Y')
+{
+uprintf("(*s_etat_processus).mode_evaluation_expression == 'Y'\n");
+	/*
+	 * Reprise sur erreur
+	 */
+
+	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_start) ||
+						TEST(instruction_select) ||
+						TEST(instruction_case) ||
+						TEST(vers_niveau_superieur))
+				{
+					if (TEST(vers_niveau_superieur))
+					{
+						analyse(s_etat_processus, vers_niveau_superieur);
+
+						if ((*s_etat_processus).erreur_systeme != d_es)
+						{
+							(*s_etat_processus).instruction_courante =
+									instruction_courante;
+							return(d_erreur);
+						}
+					}
+					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)
+						{
+							(*s_etat_processus).instruction_courante =
+									instruction_courante;
+							return(d_erreur);
+						}
+					}
+					else
+					{
+						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;
+
+	(*s_etat_processus).exception = d_ep;
+	(*s_etat_processus).erreur_execution = d_ex;
+
+	erreur_evaluation = d_erreur;
+}
+else
+{
+uprintf("Default\n");
+	// 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_start) ||
+						TEST(instruction_select) ||
+						TEST(instruction_case) ||
+						TEST(vers_niveau_superieur))
+				{
+					if (TEST(vers_niveau_superieur))
+					{
+						analyse(s_etat_processus, vers_niveau_superieur);
+
+						if ((*s_etat_processus).erreur_systeme != d_es)
+						{
+							(*s_etat_processus).instruction_courante =
+									instruction_courante;
+							return(d_erreur);
+						}
+					}
+					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)
+						{
+							(*s_etat_processus).instruction_courante =
+									instruction_courante;
+							return(d_erreur);
+						}
+					}
+					else
+					{
+						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);
+	}
+
+	if ((*s_etat_processus).var_volatile_processus_pere == 0)
+	{
+		kill((*s_etat_processus).pid_processus_pere, SIGALRM);
+	}
+	else
+	{
+		(*s_etat_processus).var_volatile_alarme = -1;
+	}
+
+	(*s_etat_processus).erreur_execution = registre_erreur_execution;
+	(*s_etat_processus).erreur_systeme = registre_erreur_systeme;
+	(*s_etat_processus).exception = registre_exception;
+printf("%d\n", (*s_etat_processus).erreur_execution);
+printf("<%d>\n", (*s_etat_processus).invalidation_message_erreur);
+	return(d_erreur);
+}
+
+/*
+================================================================================
+  Fin de la réindentation
+================================================================================
+*/
+
+							}
+						}
 					}
 					else
 					{
@@ -5099,6 +5569,10 @@ evaluation(struct_processus *s_etat_proc
 							((*s_etat_processus).erreur_execution != d_ex) ||
 							((*s_etat_processus).exception != d_ep))
 					{
+						// Il est anormal de récupérer ici une erreur
+						// d'exécution puisqu'on empile une constante
+						// symbolique.
+
 						if (presence_egalite == d_vrai)
 						{
 							liberation(s_etat_processus, s_objet_evalue);