--- rpl/src/evaluation.c	2015/02/16 19:49:38	1.88
+++ rpl/src/evaluation.c	2017/08/03 17:17:42	1.108
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.20
-  Copyright (C) 1989-2015 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.28
+  Copyright (C) 1989-2017 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -786,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
 						{
@@ -1980,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
 							{
@@ -3082,6 +3084,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);
+								}
+							}
+						}
 					}
 
 					/*
@@ -3239,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) ||
@@ -3656,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)
@@ -3767,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
 						{
@@ -4198,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)
@@ -4237,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 =
@@ -4989,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
 							{
@@ -5017,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
 						{
@@ -5052,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')
 							{
@@ -5448,6 +5614,8 @@ 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)
@@ -5492,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);
@@ -6238,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
 							{
@@ -7531,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);