--- rpl/src/evaluation.c	2010/01/26 15:22:44	1.1.1.1
+++ rpl/src/evaluation.c	2010/03/09 10:18:43	1.8
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
+  RPL/2 (R) version 4.0.13
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -82,6 +82,7 @@ evaluation(struct_processus *s_etat_proc
 	unsigned char					*instruction_courante;
 	unsigned char					*message;
 	unsigned char					registre_evaluation_expression_compilee;
+	unsigned char					registre_evaluation_forcee;
 	unsigned char					registre_instruction_valide;
 	unsigned char					registre_mode_execution_programme;
 	unsigned char					registre_retour_definition;
@@ -327,8 +328,18 @@ evaluation(struct_processus *s_etat_proc
 					}
 				}
 
+				registre_evaluation_forcee =
+						(*s_etat_processus).evaluation_forcee;
+
+				if (type_evaluation == 'N')
+				{
+					(*s_etat_processus).evaluation_forcee = 'Y';
+				}
+
 				if (sequenceur(s_etat_processus) == d_erreur)
 				{
+					(*s_etat_processus).evaluation_forcee =
+							registre_evaluation_forcee;
 					(*s_etat_processus).mode_execution_programme =
 							registre_mode_execution_programme;
 					(*s_etat_processus).instruction_courante =
@@ -336,6 +347,8 @@ evaluation(struct_processus *s_etat_proc
 					return(d_erreur);
 				}
 
+				(*s_etat_processus).evaluation_forcee =
+						registre_evaluation_forcee;
 				(*s_etat_processus).instruction_courante =
 						instruction_courante;
 				(*s_etat_processus).mode_execution_programme = 'N';
@@ -864,6 +877,15 @@ evaluation(struct_processus *s_etat_proc
 												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)
@@ -910,6 +932,15 @@ evaluation(struct_processus *s_etat_proc
 												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)
@@ -1048,6 +1079,15 @@ evaluation(struct_processus *s_etat_proc
 											{
 												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
 											{
@@ -1081,6 +1121,15 @@ evaluation(struct_processus *s_etat_proc
 											{
 												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
 											{
@@ -1183,6 +1232,15 @@ evaluation(struct_processus *s_etat_proc
 											{
 												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
 											{
@@ -1216,6 +1274,15 @@ evaluation(struct_processus *s_etat_proc
 											{
 												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
 											{
@@ -2792,8 +2859,19 @@ evaluation(struct_processus *s_etat_proc
 							}
 						}
 
+						registre_evaluation_forcee =
+								(*s_etat_processus).evaluation_forcee;
+
+						if (type_evaluation == 'N')
+						{
+							(*s_etat_processus).evaluation_forcee = 'Y';
+						}
+
 						if (sequenceur(s_etat_processus) == d_erreur)
 						{
+							(*s_etat_processus).evaluation_forcee =
+									registre_evaluation_forcee;
+
 							if (presence_variable_partagee == d_vrai)
 							{
 								(*s_etat_processus).s_liste_variables
@@ -2822,6 +2900,8 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 
+						(*s_etat_processus).evaluation_forcee =
+								registre_evaluation_forcee;
 						(*s_etat_processus).instruction_courante =
 								instruction_courante;
 						(*s_etat_processus).mode_execution_programme = 'N';
@@ -3091,9 +3171,1192 @@ evaluation(struct_processus *s_etat_proc
 					registre_test_2 = (*s_etat_processus).test_instruction;
 					(*s_etat_processus).test_instruction = 'N';
 
+					registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
+							== d_vrai) ? 'E' : 'N';
+
+					if (type_evaluation == 'N')
+					{
+						cf(s_etat_processus, 35);
+					}
+					else
+					{
+						sf(s_etat_processus, 35);
+					}
+
 					analyse(s_etat_processus, NULL);
 
+					if (registre_type_evaluation == 'E')
+					{
+						sf(s_etat_processus, 35);
+					}
+					else
+					{
+						cf(s_etat_processus, 35);
+					}
+
 					(*s_etat_processus).test_instruction = registre_test_2;
+
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						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).instruction_courante =
+								instruction_courante;
+						return(d_erreur);
+					}
+					else if (((*s_etat_processus).erreur_execution != d_ex) ||
+							((*s_etat_processus).exception != d_ep))
+					{
+						if ((*s_etat_processus).arret_si_exception == d_faux)
+						{
+							/*
+							 * 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')
+						{
+							/*
+							 * 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
+						{
+							// 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;
+							return(d_erreur);
+						}
+					}
+
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						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).instruction_courante =
+								instruction_courante;
+						return(d_erreur);
+					}
+					else if (((*s_etat_processus).erreur_execution != d_ex) ||
+							((*s_etat_processus).exception != d_ep))
+					{
+						if ((*s_etat_processus).arret_si_exception == d_faux)
+						{
+							/*
+							 * 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')
+						{
+							/*
+							 * 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
+						{
+							// 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;
+							return(d_erreur);
+						}
+					}
 				}
 				else if ((*s_etat_processus).constante_symbolique == 'N')
 				{
@@ -3316,8 +4579,19 @@ evaluation(struct_processus *s_etat_proc
 							}
 						}
 
+						registre_evaluation_forcee =
+								(*s_etat_processus).evaluation_forcee;
+
+						if (type_evaluation == 'N')
+						{
+							(*s_etat_processus).evaluation_forcee = 'Y';
+						}
+
 						if (sequenceur(s_etat_processus) == d_erreur)
 						{
+							(*s_etat_processus).evaluation_forcee =
+								registre_evaluation_forcee;
+
 							if (presence_egalite == d_vrai)
 							{
 								liberation(s_etat_processus, s_objet_evalue);
@@ -3330,6 +4604,8 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 
+						(*s_etat_processus).evaluation_forcee =
+							registre_evaluation_forcee;
 						(*s_etat_processus).instruction_courante =
 								instruction_courante;
 						(*s_etat_processus).mode_execution_programme = 'N';