--- rpl/src/evaluation.c	2014/07/17 08:07:17	1.84
+++ rpl/src/evaluation.c	2016/08/26 08:57:55	1.102
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.19
-  Copyright (C) 1989-2014 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.25
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -31,14 +31,14 @@
 ================================================================================
   Evaluation d'une expression
 ================================================================================
-  Entrées :
+  Entrées :
     structure processus,
-	objet à évaluer (non libéré au retour de la routine)
+	objet à évaluer (non libéré au retour de la routine)
 	et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')
 --------------------------------------------------------------------------------
-  Sorties : objet évalué au niveau 1 de la pile
+  Sorties : objet évalué au niveau 1 de la pile
 --------------------------------------------------------------------------------
-  Effets de bord : néant
+  Effets de bord : néant
 ================================================================================
 */
 
@@ -176,7 +176,7 @@ evaluation(struct_processus *s_etat_proc
 					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
-						// Variable partagée
+						// Variable partagée
 
 						presence_variable_partagee = d_faux;
 
@@ -236,7 +236,7 @@ evaluation(struct_processus *s_etat_proc
 					}
 					else
 					{
-						// Variable privée
+						// Variable privée
 
 						presence_variable = d_vrai;
 
@@ -571,10 +571,10 @@ evaluation(struct_processus *s_etat_proc
 
 		if (presence_egalite == d_vrai)
 		{
-			// S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
-			// le signe '=' et en le remplaçant d'une part par SWAP DROP
-			// et d'autre part par DROP. On évalue la première puis la
-			// seconde normalement avant de reconstituer le tout à la fin
+			// S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
+			// le signe '=' et en le remplaçant d'une part par SWAP DROP
+			// et d'autre part par DROP. On évalue la première puis la
+			// seconde normalement avant de reconstituer le tout à la fin
 			// de la routine.
 
 			l_registre_pile_operationnelle = NULL;
@@ -633,8 +633,8 @@ evaluation(struct_processus *s_etat_proc
 				return(d_erreur);
 			}
 
-			// Récupération de l'objet au niveau 1 résultat de l'évaluation
-			// du premier membre de l'équation puis destruction de la pile.
+			// Récupération de l'objet au niveau 1 résultat de l'évaluation
+			// du premier membre de l'équation puis destruction de la pile.
 
 			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 					&s_objet_evalue) == d_erreur)
@@ -646,7 +646,7 @@ evaluation(struct_processus *s_etat_proc
 
 			instruction_clear(s_etat_processus);
 
-			// Régénération de la pile initiale
+			// Régénération de la pile initiale
 
 			while(depilement(s_etat_processus, &l_registre_pile_operationnelle,
 					&s_sous_objet) != d_erreur)
@@ -710,7 +710,7 @@ evaluation(struct_processus *s_etat_proc
 		}
 
 		/*
-		 * Exécution de la séquence d'instructions
+		 * Exécution de la séquence d'instructions
 		 */
 
 		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
@@ -731,8 +731,8 @@ evaluation(struct_processus *s_etat_proc
 			if ((*(*l_element_courant).donnee).type == FCT)
 			{
 				/*
-				 * Tester la cohérence avec une variable pour récupérer les
-				 * données selon les indices passés en argument (tableaux,
+				 * Tester la cohérence avec une variable pour récupérer les
+				 * données selon les indices passés en argument (tableaux,
 				 * listes...).
 				 */
 
@@ -758,18 +758,8 @@ evaluation(struct_processus *s_etat_proc
 								(*s_etat_processus)
 								.evaluation_expression_compilee;
 
-						if (((*(*s_etat_processus).pointeur_variable_courante)
-								.origine == 'E') && ((*(*s_etat_processus)
-								.pointeur_variable_courante).niveau == 0))
-						{
-							(*s_etat_processus).evaluation_expression_compilee
-									= 'Y';
-						}
-						else
-						{
-							(*s_etat_processus).evaluation_expression_compilee
-									= 'N';
-						}
+						(*s_etat_processus).evaluation_expression_compilee
+								= 'Y';
 
 						analyse(s_etat_processus, (*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
@@ -796,7 +786,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -876,8 +867,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1025,7 +1016,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1142,7 +1133,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section
 												// critique
 
@@ -1268,8 +1259,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1391,7 +1382,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1508,7 +1499,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section
 												// critique
 
@@ -1607,7 +1598,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -1645,8 +1636,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -1776,7 +1767,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -1893,7 +1884,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour
+												// Traitement spécifique pour
 												// la fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -1990,7 +1981,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -2015,7 +2007,7 @@ evaluation(struct_processus *s_etat_proc
 					else
 					{
 						/*
-						 * Régénération de la fonction en notation algébrique
+						 * Régénération de la fonction en notation algébrique
 						 */
 
 						if ((s_objet_elementaire = (struct_objet *)
@@ -2201,7 +2193,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 
 						/*
-						 * Clôture de l'expression
+						 * Clôture de l'expression
 						 */
 
 						if (((*l_element_fonction).suivant =
@@ -2310,7 +2302,7 @@ evaluation(struct_processus *s_etat_proc
 								.pointeur_variable_courante).variable_partagee,
 								'E') != NULL)
 						{
-							// Une variable partagée existe.
+							// Une variable partagée existe.
 
 							presence_variable_partagee = d_vrai;
 
@@ -2330,13 +2322,13 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche d'un élément dans un vecteur
+					 * Recherche d'un élément dans un vecteur
 					 */
 
 					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
-						// La variable partagée n'existe plus.
+						// La variable partagée n'existe plus.
 
 						free(s_objet_elementaire);
 
@@ -2620,7 +2612,7 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche d'un élément dans une matrice
+					 * Recherche d'un élément dans une matrice
 					 */
 
 					else if ((((*((*(*s_etat_processus)
@@ -2928,7 +2920,7 @@ evaluation(struct_processus *s_etat_proc
 					}
 
 					/*
-					 * Recherche de l'élément idoine dans la liste
+					 * Recherche de l'élément idoine dans la liste
 					 */
 
 					else if (((*((*(*s_etat_processus)
@@ -3092,10 +3084,90 @@ evaluation(struct_processus *s_etat_proc
 									instruction_courante;
 							return(d_erreur);
 						}
+
+						// Si l'objet élémentaire est un nom et que ce nom n'est
+						// pas un nom symbolique, il convient de l'évaluer.
+
+						if ((*s_objet_elementaire).type == NOM)
+						{
+							if (((*((struct_nom *) (*s_objet_elementaire)
+									.objet)).symbole == d_faux) ||
+									(type_evaluation == 'N'))
+							{
+								if (evaluation(s_etat_processus,
+										s_objet_elementaire, 'E') == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								liberation(s_etat_processus,
+										s_objet_elementaire);
+
+
+								if (depilement(s_etat_processus,
+										&((*s_etat_processus).l_base_pile),
+										&s_objet_elementaire) == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
 					}
 
 					/*
-					 * Recherche de l'élément idoine dans la table
+					 * Recherche de l'élément idoine dans la table
 					 */
 
 					else if (((*((*(*s_etat_processus)
@@ -3249,6 +3321,86 @@ evaluation(struct_processus *s_etat_proc
 									instruction_courante;
 							return(d_erreur);
 						}
+
+						// Si l'objet élémentaire est un nom et que ce nom n'est
+						// pas un nom symbolique, il convient de l'évaluer.
+
+						if ((*s_objet_elementaire).type == NOM)
+						{
+							if (((*((struct_nom *) (*s_objet_elementaire)
+									.objet)).symbole == d_faux) ||
+									(type_evaluation == 'N'))
+							{
+								if (evaluation(s_etat_processus,
+										s_objet_elementaire, 'E') == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+
+								liberation(s_etat_processus,
+										s_objet_elementaire);
+
+
+								if (depilement(s_etat_processus,
+										&((*s_etat_processus).l_base_pile),
+										&s_objet_elementaire) == d_erreur)
+								{
+									if (presence_variable_partagee == d_vrai)
+									{
+										(*(*s_etat_processus)
+												.pointeur_variable_courante)
+												.objet = NULL;
+
+										if (pthread_mutex_unlock(
+											&((*(*s_etat_processus)
+											.pointeur_variable_partagee_courante
+											).mutex)) != 0)
+										{
+											(*s_etat_processus).erreur_systeme =
+													d_es_processus;
+										}
+									}
+
+									if (presence_egalite == d_vrai)
+									{
+										liberation(s_etat_processus,
+												s_objet_evalue);
+									}
+
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									(*s_etat_processus).instruction_courante =
+											instruction_courante;
+									return(d_erreur);
+								}
+							}
+						}
 					}
 					else if (((*((*(*s_etat_processus)
 							.pointeur_variable_courante).objet)).type == ALG) ||
@@ -3666,7 +3818,7 @@ evaluation(struct_processus *s_etat_proc
 								.evaluation_expression_compilee;
 
 						(*s_etat_processus).evaluation_expression_compilee
-								= 'N';
+								= 'Y';
 
 						if (evaluation(s_etat_processus, (*l_element_courant)
 								.donnee, type_evaluation) == d_erreur)
@@ -3777,7 +3929,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -3856,8 +4009,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4005,7 +4158,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4122,7 +4275,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -4208,6 +4361,8 @@ evaluation(struct_processus *s_etat_proc
 
 							do
 							{
+								l_element_courant = (*l_element_courant)
+										.suivant;
 								l_registre_atome = l_element_courant;
 
 								if (l_element_courant == NULL)
@@ -4247,9 +4402,6 @@ evaluation(struct_processus *s_etat_proc
 									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 =
@@ -4289,8 +4441,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4412,7 +4564,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4529,7 +4681,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -4624,7 +4776,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -4662,8 +4814,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -4785,7 +4937,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -4902,7 +5054,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -4999,7 +5151,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -5027,7 +5180,8 @@ evaluation(struct_processus *s_etat_proc
 								== 0)
 						{
 							envoi_signal_processus((*s_etat_processus)
-									.pid_processus_pere, rpl_sigalrm);
+									.pid_processus_pere, rpl_sigalrm,
+									d_faux);
 						}
 						else
 						{
@@ -5062,6 +5216,8 @@ evaluation(struct_processus *s_etat_proc
 
 							free(message);
 
+							l_registre_atome = l_element_courant;
+
 							while((*(*s_etat_processus).l_base_pile_systeme)
 									.clause != 'R')
 							{
@@ -5106,8 +5262,8 @@ evaluation(struct_processus *s_etat_proc
 												.objet)).fonction;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -5255,7 +5411,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -5372,7 +5528,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -5458,13 +5614,15 @@ evaluation(struct_processus *s_etat_proc
 
 							do
 							{
+								(*s_etat_processus).expression_courante =
+										l_registre_atome;
 								l_registre_atome = l_element_courant;
 
 								if (l_element_courant == NULL)
 								{
 									/*
 									 * La fin de l'expression est atteinte,
-									 * le séquenceur reprend la main.
+									 * le séquenceur reprend la main.
 									 */
 
 									if (presence_egalite == d_vrai)
@@ -5502,9 +5660,6 @@ evaluation(struct_processus *s_etat_proc
 										.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);
@@ -5539,8 +5694,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -5662,7 +5817,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -5779,7 +5934,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -5874,7 +6029,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 						else
 						{
-							// On ne détruit pas les variables pour les inclure
+							// On ne détruit pas les variables pour les inclure
 							// dans le fichier rpl-core.
 
 							(*s_etat_processus).gel_liste_variables = d_vrai;
@@ -5912,8 +6067,8 @@ evaluation(struct_processus *s_etat_proc
 												= d_es;
 
 										/*
-										 * Traitement de la pile système par les
-										 * différentes instructions.
+										 * Traitement de la pile système par les
+										 * différentes instructions.
 										 */
 
 										if (TEST(instruction_if) ||
@@ -6035,7 +6190,7 @@ evaluation(struct_processus *s_etat_proc
 													.type_cloture != 'L'))
 											{
 												/*
-												 * Libération des compteurs
+												 * Libération des compteurs
 												 * de boucle
 												 */
 
@@ -6152,7 +6307,7 @@ evaluation(struct_processus *s_etat_proc
 											}
 											else
 											{
-												// Traitement spécifique pour la
+												// Traitement spécifique pour la
 												// fin d'une section critique
 
 												if ((*s_etat_processus)
@@ -6248,7 +6403,8 @@ evaluation(struct_processus *s_etat_proc
 									.var_volatile_processus_pere == 0)
 							{
 								envoi_signal_processus((*s_etat_processus)
-										.pid_processus_pere, rpl_sigalrm);
+										.pid_processus_pere, rpl_sigalrm,
+										d_faux);
 							}
 							else
 							{
@@ -6327,7 +6483,7 @@ evaluation(struct_processus *s_etat_proc
 							if ((*(*s_etat_processus)
 									.pointeur_variable_courante).objet == NULL)
 							{
-								// Variable partagée
+								// Variable partagée
 
 								presence_variable_partagee = d_faux;
 
@@ -6418,8 +6574,8 @@ evaluation(struct_processus *s_etat_proc
 						if ((*((struct_nom *) (*(*l_element_courant).donnee)
 								.objet)).symbole == d_vrai)
 						{
-							// L'objet apparaît comme un symbole dans
-							// l'expression en cours d'évaluation. On se
+							// L'objet apparaît comme un symbole dans
+							// l'expression en cours d'évaluation. On se
 							// contente de l'empiler.
 
 							if ((s_sous_objet = copie_objet(s_etat_processus,
@@ -6731,7 +6887,7 @@ evaluation(struct_processus *s_etat_proc
 									// Reprise sur erreur.
 
 //==============================================================================
-//  Réindentation
+//  Réindentation
 //==============================================================================
 
 			drapeau_then = d_faux;
@@ -6774,8 +6930,8 @@ evaluation(struct_processus *s_etat_proc
 								.objet)).fonction;
 
 						/*
-						 * Traitement de la pile système par les
-						 * différentes instructions.
+						 * Traitement de la pile système par les
+						 * différentes instructions.
 						 */
 
 						if (TEST(instruction_if) ||
@@ -6898,7 +7054,7 @@ evaluation(struct_processus *s_etat_proc
 									.type_cloture != 'L'))
 							{
 								/*
-								 * Libération des compteurs
+								 * Libération des compteurs
 								 * de boucle
 								 */
 
@@ -6990,7 +7146,7 @@ evaluation(struct_processus *s_etat_proc
 							}
 							else
 							{
-								// Traitement spécifique pour
+								// Traitement spécifique pour
 								// la fin d'une section
 								// critique
 
@@ -7071,7 +7227,7 @@ evaluation(struct_processus *s_etat_proc
 			(*s_etat_processus).erreur_execution = d_ex;
 
 //==============================================================================
-//  Fin de la réindentation
+//  Fin de la réindentation
 //==============================================================================
 								}
 							}
@@ -7169,7 +7325,7 @@ evaluation(struct_processus *s_etat_proc
 						}
 
 						/*
-						 * Vérification du drapeau symbole pour
+						 * Vérification du drapeau symbole pour
 						 * savoir si l'on met dans la pile le nom
 						 * ou le contenu de la variable.
 						 */
@@ -7186,7 +7342,7 @@ evaluation(struct_processus *s_etat_proc
 										.pointeur_variable_courante).objet
 										== NULL)
 								{
-									// Variable partagée
+									// Variable partagée
 
 									if (recherche_variable_partagee(
 											s_etat_processus,
@@ -7243,7 +7399,7 @@ evaluation(struct_processus *s_etat_proc
 								}
 								else
 								{
-									// Variable privée
+									// Variable privée
 
 									liberation(s_etat_processus,
 											s_objet_elementaire);
@@ -7327,8 +7483,8 @@ 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
+						// Il est anormal de récupérer ici une erreur
+						// d'exécution puisqu'on empile une constante
 						// symbolique.
 
 						if (presence_egalite == d_vrai)
@@ -7425,8 +7581,8 @@ evaluation(struct_processus *s_etat_proc
 		if (niveau_initial < (*s_etat_processus).niveau_courant)
 		{
 			/*
-			 * Retrait des variables dans le cas où l'évaluation de
-			 * l'expression a été interrompue
+			 * Retrait des variables dans le cas où l'évaluation de
+			 * l'expression a été interrompue
 			 */
 
 			(*s_etat_processus).niveau_courant = niveau_initial;
@@ -7447,7 +7603,7 @@ evaluation(struct_processus *s_etat_proc
 		}
 
 		/*
-		 * Retrait des variables statiques créées dans l'expression
+		 * Retrait des variables statiques créées dans l'expression
 		 */
 
 		if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
@@ -7465,7 +7621,7 @@ evaluation(struct_processus *s_etat_proc
 		}
 
 		/*
-		 * Retrait des variables partagées créées dans l'expression
+		 * Retrait des variables partagées créées dans l'expression
 		 */
 
 		if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
@@ -7484,7 +7640,7 @@ evaluation(struct_processus *s_etat_proc
 
 		if ((*s_etat_processus).var_volatile_requete_arret != 0)
 		{
-			// Restauration de la pile système
+			// Restauration de la pile système
 
 			while(pile_systeme_originelle !=
 					(*s_etat_processus).l_base_pile_systeme)
@@ -7495,7 +7651,7 @@ evaluation(struct_processus *s_etat_proc
 
 		if (presence_egalite == d_vrai)
 		{
-			// Ajout du membre évalué lors de la première passe
+			// Ajout du membre évalué lors de la première passe
 
 			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 					s_objet_evalue) == d_erreur)
@@ -7541,7 +7697,15 @@ evaluation(struct_processus *s_etat_proc
 
 		registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
 				? 'E' : 'N';
-		cf(s_etat_processus, 35);
+
+		if (type_evaluation == 'N')
+		{
+			cf(s_etat_processus, 35);
+		}
+		else
+		{
+			sf(s_etat_processus, 35);
+		}
 
 		analyse(s_etat_processus, (*((struct_fonction *)
 				(*s_objet).objet)).fonction);