--- rpl/src/sequenceur.c	2010/01/26 15:22:45	1.1
+++ rpl/src/sequenceur.c	2011/04/11 12:10:12	1.30
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.0.prerelease.0
+  Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,12 +20,12 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
 ================================================================================
-  Boucle principale de l'interpréteur RPL/2
+  Boucle principale de l'interprète RPL/2
 ================================================================================
   Entrées : structure sur l'état du processus
 --------------------------------------------------------------------------------
@@ -41,6 +41,7 @@ sequenceur(struct_processus *s_etat_proc
 	struct_liste_chainee		*l_element_courant;
 
 	struct_objet				*s_objet;
+	struct_objet				*s_objet_evaluation;
 	struct_objet				*s_sous_objet;
 
 	logical1					drapeau_appel_definition;
@@ -103,7 +104,7 @@ sequenceur(struct_processus *s_etat_proc
 
 /*
 --------------------------------------------------------------------------------
-  Boucle de l'interpréteur RPL/2
+  Boucle de l'interprète RPL/2
   On boucle tant qu'on n'a pas une bonne raison de sortir...
 --------------------------------------------------------------------------------
 */
@@ -198,6 +199,7 @@ sequenceur(struct_processus *s_etat_proc
 							(*s_etat_processus).localisation, d_locale))
 							== NULL)
 					{
+						free((*s_etat_processus).instruction_courante);
 						return(d_erreur);
 					}
 
@@ -282,8 +284,11 @@ sequenceur(struct_processus *s_etat_proc
 
 					tampon = (*s_etat_processus).instruction_courante;
 					(*s_etat_processus).instruction_courante = ligne;
+
 					recherche_type(s_etat_processus);
 
+					(*s_etat_processus).instruction_courante = tampon;
+
 					if ((((*s_etat_processus).erreur_execution != d_ex) ||
 							((*s_etat_processus).erreur_systeme != d_es)) &&
 							((*s_etat_processus).invalidation_message_erreur
@@ -301,6 +306,7 @@ sequenceur(struct_processus *s_etat_proc
 
 						if ((message = messages(s_etat_processus)) == NULL)
 						{
+							free((*s_etat_processus).instruction_courante);
 							return(d_erreur);
 						}
 
@@ -360,12 +366,15 @@ sequenceur(struct_processus *s_etat_proc
 								if ((message = messages(s_etat_processus))
 										== NULL)
 								{
+									free((*s_etat_processus)
+											.instruction_courante);
 									return(d_erreur);
 								}
 
 								printf("%s [%d]\n", message, (int) getpid());
-								free(message);
 
+								free(message);
+								free((*s_etat_processus).instruction_courante);
 								return(d_erreur);
 							}
 							else if ((*s_etat_processus)
@@ -383,6 +392,8 @@ sequenceur(struct_processus *s_etat_proc
 								if ((message = messages(s_etat_processus))
 										== NULL)
 								{
+									free((*s_etat_processus)
+											.instruction_courante);
 									return(d_erreur);
 								}
 
@@ -433,8 +444,6 @@ sequenceur(struct_processus *s_etat_proc
 						(*(*s_etat_processus).l_base_pile_systeme)
 								.retour_definition = tampon_retour;
 					}
-
-					(*s_etat_processus).instruction_courante = tampon;
 				}
 				else if ((*s_etat_processus).invalidation_message_erreur
 						== d_faux)
@@ -450,6 +459,7 @@ sequenceur(struct_processus *s_etat_proc
 
 					if ((message = messages(s_etat_processus)) == NULL)
 					{
+						free((*s_etat_processus).instruction_courante);
 						free(ligne);
 						return(d_erreur);
 					}
@@ -497,7 +507,7 @@ sequenceur(struct_processus *s_etat_proc
 /*
 --------------------------------------------------------------------------------
   Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le
-  cas contraire, l'interpréteur renvoie un message d'erreur et s'interrompt.
+  cas contraire, l'interprète renvoie un message d'erreur et s'interrompt.
 --------------------------------------------------------------------------------
 */
 
@@ -805,6 +815,75 @@ sequenceur(struct_processus *s_etat_proc
 
 					(*s_etat_processus).erreur_systeme = d_es;
 					recherche_type(s_etat_processus);
+
+					if ((*s_etat_processus).autorisation_nom_implicite == 'N')
+					{
+						if ((*s_etat_processus).l_base_pile == NULL)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_manque_argument;
+						}
+						else if ((*(*(*s_etat_processus).l_base_pile).donnee)
+								.type == NOM)
+						{
+							if ((*((struct_nom *) (*(*(*s_etat_processus)
+									.l_base_pile).donnee).objet)).symbole
+									== d_faux)
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_nom_implicite;
+
+								// Si le niveau de récursivité est non nul, on
+								// arrive ici depuis la fonction
+								// recherche_type(). On retourne à cette
+								// dernière en indiquant une erreur.
+
+								if ((*s_etat_processus).niveau_recursivite != 0)
+								{
+									free((*s_etat_processus)
+											.instruction_courante);
+									return(d_erreur);
+								}
+							}
+						}
+					}
+
+					// Le séquenceur est appelé depuis la routine d'évaluation
+
+					if ((*s_etat_processus).evaluation_forcee == 'Y')
+					{
+						if (depilement(s_etat_processus,
+								&((*s_etat_processus).l_base_pile),
+								&s_objet_evaluation) == d_erreur)
+						{
+							free((*s_etat_processus).instruction_courante);
+							(*s_etat_processus).erreur_execution =
+									d_ex_manque_argument;
+							return(d_erreur);
+						}
+
+						if (evaluation(s_etat_processus, s_objet_evaluation,
+								'N') == d_erreur)
+						{
+							free((*s_etat_processus).instruction_courante);
+							liberation(s_etat_processus, s_objet_evaluation);
+							return(d_erreur);
+						}
+
+						liberation(s_etat_processus, s_objet_evaluation);
+					}
+
+					// Le séquenceur est appelé depuis la routine de
+					// recherche de type
+
+					else if ((*s_etat_processus).recherche_type == 'Y')
+					{
+						if ((*s_etat_processus).erreur_execution != d_ex)
+						{
+							free((*s_etat_processus).instruction_courante);
+							return(d_erreur);
+						}
+					}
 				}
 			}
 			else if (((*s_etat_processus).test_instruction == 'Y') &&
@@ -829,19 +908,7 @@ sequenceur(struct_processus *s_etat_proc
 						!= 0) && (strcmp((*s_etat_processus)
 						.instruction_courante, ">>") != 0))
 				{
-					if ((s_objet = (struct_objet *) malloc(
-							sizeof(struct_objet))) == NULL)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						return(d_erreur);
-					}
-
-					initialisation_objet(s_objet);
-					(*s_objet).type = FCT;
-
-					if (((*s_objet).objet = allocation(s_etat_processus, FCT))
-							== NULL)
+					if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
@@ -924,6 +991,7 @@ sequenceur(struct_processus *s_etat_proc
 
 			fflush(stdout);
 
+			free((*s_etat_processus).instruction_courante);
 			return(d_erreur);
 		}
 
@@ -1005,6 +1073,7 @@ sequenceur(struct_processus *s_etat_proc
 
 			if ((message = messages(s_etat_processus)) == NULL)
 			{
+				free((*s_etat_processus).instruction_courante);
 				return(d_erreur);
 			}
 
@@ -1091,6 +1160,7 @@ sequenceur(struct_processus *s_etat_proc
 
 					if (erreur == d_erreur)
 					{
+						free((*s_etat_processus).instruction_courante);
 						return(d_erreur);
 					}
 
@@ -1112,6 +1182,7 @@ sequenceur(struct_processus *s_etat_proc
 
 							if ((*s_etat_processus).erreur_systeme != d_es)
 							{
+								free((*s_etat_processus).instruction_courante);
 								return(d_erreur);
 							}
 
@@ -1145,6 +1216,7 @@ sequenceur(struct_processus *s_etat_proc
 
 						if (instruction_majuscule == NULL)
 						{
+							free((*s_etat_processus).instruction_courante);
 							return(d_erreur);
 						}