--- rpl/src/evaluation.c	2010/04/17 18:57:35	1.11
+++ rpl/src/evaluation.c	2010/04/20 12:49:18	1.12
@@ -19,7 +19,7 @@
 ================================================================================
 */
 
-#define DEBUG_RETURN
+
 #include "rpl.conv.h"
 
 #define TEST(instruction) (fonction == instruction)
@@ -143,15 +143,31 @@ evaluation(struct_processus *s_etat_proc
 			if (recherche_variable(s_etat_processus, (*((struct_nom *)
 					(*s_objet_tampon).objet)).nom) == d_faux)
 			{
+				(*s_etat_processus).erreur_execution = d_ex;
+
 				if ((*s_etat_processus).autorisation_nom_implicite == 'N')
 				{
 					if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
 							d_faux)
 					{
-uprintf("Paf !\n");
+						if (test_cfsf(s_etat_processus, 31) == d_vrai)
+						{
+							if (empilement_pile_last(s_etat_processus, 0)
+									== d_erreur)
+							{
+								return(d_erreur);
+							}
+						}
+
+						erreur_evaluation = d_erreur;
 						(*s_etat_processus).erreur_execution =
 								d_ex_nom_implicite;
-						return(d_erreur);
+
+						if (type_evaluation == 'I')
+						{
+							(*s_etat_processus).derniere_erreur_evaluation =
+									(*s_etat_processus).erreur_execution;
+						}
 					}
 				}
 
@@ -475,10 +491,10 @@ uprintf("Paf !\n");
 				(*s_etat_processus).evaluation_expression_compilee =
 						registre_evaluation_expression_compilee;
 			}
-			else
+			else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
 			{
 				if ((s_objet_tampon = copie_objet(s_etat_processus,
-						s_objet, 'P')) == NULL)
+						s_objet, 'Q')) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -496,12 +512,6 @@ uprintf("Paf !\n");
 							instruction_courante;
 					return(d_erreur);
 				}
-
-				if ((*s_etat_processus).erreur_execution ==
-						d_ex_variable_non_definie)
-				{
-					(*s_etat_processus).erreur_execution = d_ex;
-				}
 			}
 		}
 		else
@@ -4402,478 +4412,26 @@ uprintf("Paf !\n");
 							if ((*((struct_nom *) (*s_objet_elementaire).objet))
 									.symbole == d_faux)
 							{
-uprintf("Pif\n");
+								if (test_cfsf(s_etat_processus, 31) == d_vrai)
+								{
+									if (empilement_pile_last(s_etat_processus,
+											0) == d_erreur)
+									{
+										return(d_erreur);
+									}
+								}
+
+								erreur_evaluation = d_erreur;
 								(*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;
-
-						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
-================================================================================
-*/
-
+								if (type_evaluation == 'I')
+								{
+									(*s_etat_processus)
+											.derniere_erreur_evaluation =
+											(*s_etat_processus)
+											.erreur_execution;
+								}
 							}
 						}
 					}