--- rpl/src/evaluation.c	2010/02/08 19:26:32	1.5
+++ rpl/src/evaluation.c	2011/06/21 15:26:28	1.39
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.10
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.0.prerelease.2
+  Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 #define TEST(instruction) (fonction == instruction)
 #define vers_niveau_inferieur instruction_vers_niveau_inferieur
@@ -76,8 +76,6 @@ evaluation(struct_processus *s_etat_proc
 	struct_objet					*s_sous_objet;
 	struct_objet					*s_copie_variable_partagee;
 
-	struct_variable					*registre_variables;
-
 	unsigned char					autorisation_empilement_programme;
 	unsigned char					*instruction_courante;
 	unsigned char					*message;
@@ -97,7 +95,6 @@ evaluation(struct_processus *s_etat_proc
 	unsigned long					k;
 	unsigned long					l;
 	unsigned long					n;
-	unsigned long					m;
 	unsigned long					niveau_initial;
 	unsigned long					nombre_termes;
 	unsigned long					registre_hauteur_pile_operationnelle;
@@ -143,6 +140,34 @@ 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)
+					{
+						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;
+
+						if (type_evaluation == 'I')
+						{
+							(*s_etat_processus).derniere_erreur_evaluation =
+									(*s_etat_processus).erreur_execution;
+						}
+					}
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es;
 				presence_variable = d_faux;
 			}
@@ -150,8 +175,7 @@ evaluation(struct_processus *s_etat_proc
 			{
 				if ((*s_etat_processus).traitement_symbolique == 'N')
 				{
-					if ((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante]
+					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
 						// Variable partagée
@@ -167,12 +191,10 @@ evaluation(struct_processus *s_etat_proc
 						presence_variable_partagee = d_faux;
 
 						if (recherche_variable_partagee(s_etat_processus,
-								((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]).nom,
-								((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante])
+								(*(*s_etat_processus)
+								.pointeur_variable_courante).nom,
+								(*(*s_etat_processus)
+								.pointeur_variable_courante)
 								.variable_partagee, 'E') == d_vrai)
 						{
 							presence_variable = d_vrai;
@@ -241,9 +263,8 @@ evaluation(struct_processus *s_etat_proc
 
 						presence_variable = d_vrai;
 
-						if ((*((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus).position_variable_courante]
-								.objet)).type == ADR)
+						if ((*(*(*s_etat_processus).pointeur_variable_courante)
+								.objet).type == ADR)
 						{
 							presence_fonction = d_vrai;
 						}
@@ -294,10 +315,8 @@ evaluation(struct_processus *s_etat_proc
 				{
 					(*s_etat_processus).position_courante =
 							(*((unsigned long *)
-							((*((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus)
-							.position_variable_courante]
-							.objet)).objet)));
+							((*(*(*s_etat_processus).pointeur_variable_courante)
+							.objet).objet)));
 				}
 				else
 				{
@@ -318,8 +337,7 @@ evaluation(struct_processus *s_etat_proc
 				if ((*s_etat_processus).profilage == d_vrai)
 				{
 					profilage(s_etat_processus,
-							(*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante]
+							(*(*s_etat_processus).pointeur_variable_courante)
 							.nom);
 
 					if ((*s_etat_processus).erreur_systeme != d_es)
@@ -371,11 +389,9 @@ evaluation(struct_processus *s_etat_proc
 				registre_evaluation_expression_compilee =
 						(*s_etat_processus).evaluation_expression_compilee;
 
-				if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-						.position_variable_courante].origine == 'E') &&
-						((*s_etat_processus).s_liste_variables
-						[(*s_etat_processus).position_variable_courante].niveau
-						== 0))
+				if (((*(*s_etat_processus).pointeur_variable_courante).origine
+						== 'E') && ((*(*s_etat_processus)
+						.pointeur_variable_courante).niveau == 0))
 				{
 					(*s_etat_processus).evaluation_expression_compilee = 'Y';
 				}
@@ -387,8 +403,7 @@ evaluation(struct_processus *s_etat_proc
 				if ((*s_etat_processus).profilage == d_vrai)
 				{
 					profilage(s_etat_processus,
-							(*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante]
+							(*(*s_etat_processus).pointeur_variable_courante)
 							.nom);
 
 					if ((*s_etat_processus).erreur_systeme != d_es)
@@ -408,11 +423,41 @@ evaluation(struct_processus *s_etat_proc
 					}
 				}
 
+				autorisation_empilement_programme = (*s_etat_processus)
+						.autorisation_empilement_programme;
+
+				empilement_pile_systeme(s_etat_processus);
+
+				if ((*s_etat_processus).erreur_systeme != d_es)
+				{
+					if (presence_variable_partagee == d_vrai)
+					{
+						liberation(s_etat_processus, s_copie_variable_partagee);
+					}
+
+					(*s_etat_processus).instruction_courante =
+							instruction_courante;
+					return(d_erreur);
+				}
+
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.retour_definition = 'Y';
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.origine_routine_evaluation = 'Y';
+
+				(*s_etat_processus).mode_execution_programme = 'Y';
+				(*s_etat_processus).autorisation_empilement_programme = 'N';
+
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.niveau_courant = (*s_etat_processus)
+						.niveau_courant;
+
+				empilement_pile_systeme(s_etat_processus);
+
 				if (presence_variable_partagee == d_faux)
 				{
-					if (evaluation(s_etat_processus, (*s_etat_processus)
-							.s_liste_variables[(*s_etat_processus)
-							.position_variable_courante].objet,
+					if (evaluation(s_etat_processus, (*(*s_etat_processus)
+							.pointeur_variable_courante).objet,
 							type_evaluation) == d_erreur)
 					{ 
 						if ((*s_etat_processus).profilage == d_vrai)
@@ -460,13 +505,23 @@ evaluation(struct_processus *s_etat_proc
 					profilage(s_etat_processus, NULL);
 				}
 
+				depilement_pile_systeme(s_etat_processus);
+				depilement_pile_systeme(s_etat_processus);
+
+				if ((*s_etat_processus).erreur_systeme != d_es)
+				{
+					return(d_erreur);
+				}
+
 				(*s_etat_processus).evaluation_expression_compilee =
 						registre_evaluation_expression_compilee;
+				(*s_etat_processus).autorisation_empilement_programme =
+						autorisation_empilement_programme;
 			}
-			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;
@@ -484,12 +539,6 @@ evaluation(struct_processus *s_etat_proc
 							instruction_courante;
 					return(d_erreur);
 				}
-
-				if ((*s_etat_processus).erreur_execution ==
-						d_ex_variable_non_definie)
-				{
-					(*s_etat_processus).erreur_execution = d_ex;
-				}
 			}
 		}
 		else
@@ -708,6 +757,8 @@ evaluation(struct_processus *s_etat_proc
 		registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
 				.retour_definition;
 		(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
+		(*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
+				s_objet;
 
 		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
 		autorisation_empilement_programme = (*s_etat_processus)
@@ -807,8 +858,9 @@ evaluation(struct_processus *s_etat_proc
 
 							free(message);
 
-							while((*(*s_etat_processus).l_base_pile_systeme)
-									.clause != 'R')
+							drapeau_then = d_faux;
+
+							while(drapeau_then == d_faux)
 							{
 								l_registre_atome = l_element_courant;
 								l_element_courant =
@@ -970,66 +1022,28 @@ evaluation(struct_processus *s_etat_proc
 												}
 											}
 										}
+										else if (TEST(instruction_then))
+										{
+											if ((*(*s_etat_processus)
+													.l_base_pile_systeme)
+													.clause == 'R')
+											{
+												(*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.clause = 'X';
+												instruction_then(
+														s_etat_processus);
+												drapeau_then = d_vrai;
+											}
+										}
 									}
 								}
 							}
 
+							(*s_etat_processus).expression_courante =
+									l_element_courant;
 							(*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;
@@ -1135,23 +1149,23 @@ evaluation(struct_processus *s_etat_proc
 											{
 												depilement_pile_systeme(
 														s_etat_processus);
+											}
 
-												if ((*s_etat_processus)
-														.erreur_systeme != d_es)
+											if ((*s_etat_processus)
+													.erreur_systeme != d_es)
+											{
+												if (presence_egalite ==
+														d_vrai)
 												{
-													if (presence_egalite ==
-															d_vrai)
-													{
-														liberation(
-															s_etat_processus,
-															s_objet_evalue);
-													}
-
-													(*s_etat_processus)
-														.instruction_courante =
-														instruction_courante;
-													return(d_erreur);
+													liberation(
+														s_etat_processus,
+														s_objet_evalue);
 												}
+
+												(*s_etat_processus)
+													.instruction_courante =
+													instruction_courante;
+												return(d_erreur);
 											}
 										}
 									}
@@ -1283,6 +1297,14 @@ evaluation(struct_processus *s_etat_proc
 														instruction_courante;
 													return(d_erreur);
 												}
+
+												if ((*(*s_etat_processus)
+														.l_base_pile_systeme)
+														.retour_definition
+														== 'Y')
+												{
+													break;
+												}
 											}
 											else
 											{
@@ -1638,9 +1660,8 @@ evaluation(struct_processus *s_etat_proc
 						return(d_erreur);
 					}
 
-					if ((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante]
-							.objet == NULL)
+					if ((*(*s_etat_processus).pointeur_variable_courante).objet
+							== NULL)
 					{
 						if (pthread_mutex_lock(&((*(*s_etat_processus)
 								.s_liste_variables_partagees).mutex)) != 0)
@@ -1650,22 +1671,18 @@ evaluation(struct_processus *s_etat_proc
 						}
 
 						if (recherche_variable_partagee(s_etat_processus,
-								((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]).nom,
-								((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante])
-								.variable_partagee, 'E') == d_vrai)
+								(*(*s_etat_processus)
+								.pointeur_variable_courante).nom,
+								(*(*s_etat_processus)
+								.pointeur_variable_courante).variable_partagee,
+								'E') == d_vrai)
 						{
 							// Une variable partagée existe.
 
 							presence_variable_partagee = d_vrai;
 
-							(*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].objet = 
-									(*(*s_etat_processus)
+							(*(*s_etat_processus).pointeur_variable_courante)
+									.objet = (*(*s_etat_processus)
 									.s_liste_variables_partagees).table
 									[(*(*s_etat_processus)
 									.s_liste_variables_partagees)
@@ -1692,8 +1709,7 @@ evaluation(struct_processus *s_etat_proc
 					 * Recherche d'un élément dans un vecteur
 					 */
 
-					if (((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
+					if ((*(*s_etat_processus).pointeur_variable_courante)
 							.objet == NULL)
 					{
 						// La variable partagée n'existe plus.
@@ -1706,9 +1722,8 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet = 
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet = 
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
@@ -1725,15 +1740,12 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);;
 						}
 					}
-					else if ((((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == VIN) ||
-							((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == VRL) ||
-							((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == VCX))
+					else if ((((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == VIN) ||
+							((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == VRL) ||
+							((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == VCX))
 							&& ((*((struct_fonction *) (*(*l_element_courant)
 							.donnee).objet)).nombre_arguments == 1))
 					{
@@ -1744,9 +1756,8 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet = 
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
@@ -1772,16 +1783,15 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 
-						if ((*s_objet_indice_i).type == INT)
+						if ((*s_objet_indice_i).type != INT)
 						{
 							liberation(s_etat_processus, s_objet_indice_i);
 							free(s_objet_elementaire);
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet = 
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
@@ -1812,18 +1822,16 @@ evaluation(struct_processus *s_etat_proc
 						liberation(s_etat_processus, s_objet_indice_i);
 
 						if ((i < 1) || (i > (integer8) (*((struct_vecteur *)
-								(*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).objet))
+								(*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).objet))
 								.taille))
 						{
 							free(s_objet_elementaire);
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet = 
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
 										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
@@ -1849,9 +1857,8 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 
-						if ((*(((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
+						if ((*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).type
 								== VIN)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
@@ -1865,10 +1872,9 @@ evaluation(struct_processus *s_etat_proc
 
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -1890,14 +1896,12 @@ evaluation(struct_processus *s_etat_proc
 							(*s_objet_elementaire).type = INT;
 							(*((integer8 *) (*s_objet_elementaire).objet)) =
 									((integer8 *) (*((struct_vecteur *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1];
 						}
-						else if ((*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
+						else if ((*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).type
 								== VRL)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
@@ -1905,10 +1909,9 @@ evaluation(struct_processus *s_etat_proc
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -1936,14 +1939,12 @@ evaluation(struct_processus *s_etat_proc
 							(*s_objet_elementaire).type = REL;
 							(*((real8 *) (*s_objet_elementaire).objet)) =
 									((real8 *) (*((struct_vecteur *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1];
 						}
-						else if ((*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
+						else if ((*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).type
 								== VCX)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
@@ -1951,10 +1952,9 @@ evaluation(struct_processus *s_etat_proc
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -1983,19 +1983,15 @@ evaluation(struct_processus *s_etat_proc
 							(*((struct_complexe16 *) (*s_objet_elementaire)
 									.objet)).partie_reelle =
 									((struct_complexe16 *) (*((struct_vecteur *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
-									.objet)).tableau)[i - 1]
-									.partie_reelle;
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
+									.objet)).tableau)[i - 1].partie_reelle;
 							(*((struct_complexe16 *) (*s_objet_elementaire)
 									.objet)).partie_imaginaire =
 									((struct_complexe16 *) (*((struct_vecteur *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
-									.objet)).tableau)[i - 1]
-									.partie_imaginaire;
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
+									.objet)).tableau)[i - 1].partie_imaginaire;
 						}
 					}
 
@@ -2003,15 +1999,12 @@ evaluation(struct_processus *s_etat_proc
 					 * Recherche d'un élément dans une matrice
 					 */
 
-					else if ((((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == MIN) ||
-							((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == MRL) ||
-							((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == MCX))
+					else if ((((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == MIN) ||
+							((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == MRL) ||
+							((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == MCX))
 							&& ((*((struct_fonction *) (*(*l_element_courant)
 							.donnee).objet)).nombre_arguments == 2))
 					{
@@ -2022,10 +2015,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2059,10 +2051,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2097,10 +2088,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2133,25 +2123,20 @@ evaluation(struct_processus *s_etat_proc
 						liberation(s_etat_processus, s_objet_indice_j);
 
 						if ((i < 1) || (i > (integer8) (*((struct_matrice *)
-								(*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).objet))
+								(*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).objet))
 								.nombre_lignes) || (j < 1) || (j > (integer8)
-								(*((struct_matrice *) (*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).objet))
+								(*((struct_matrice *) (*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).objet))
 								.nombre_colonnes))
 						{
-							liberation(s_etat_processus, s_objet_indice_i);
-							liberation(s_etat_processus, s_objet_indice_j);
 							free(s_objet_elementaire);
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2177,20 +2162,17 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 
-						if ((*(((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
-								== MIN)
+						if ((*((*(*s_etat_processus).pointeur_variable_courante)
+								.objet)).type == MIN)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
 									integer8))) == NULL)
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+									   		NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -2218,14 +2200,12 @@ evaluation(struct_processus *s_etat_proc
 							(*s_objet_elementaire).type = INT;
 							(*((integer8 *) (*s_objet_elementaire).objet)) =
 									((integer8 **) (*((struct_matrice *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1][j - 1];
 						}
-						else if ((*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
+						else if ((*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).type
 								== MRL)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
@@ -2233,10 +2213,9 @@ evaluation(struct_processus *s_etat_proc
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -2264,14 +2243,12 @@ evaluation(struct_processus *s_etat_proc
 							(*s_objet_elementaire).type = REL;
 							(*((real8 *) (*s_objet_elementaire).objet)) =
 									((real8 **) (*((struct_matrice *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1][j - 1];
 						}
-						else if ((*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).type
+						else if ((*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).type
 								== MCX)
 						{
 							if (((*s_objet_elementaire).objet = malloc(sizeof(
@@ -2279,10 +2256,9 @@ evaluation(struct_processus *s_etat_proc
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -2312,18 +2288,16 @@ evaluation(struct_processus *s_etat_proc
 									.objet)).partie_reelle =
 									((struct_complexe16 **)
 									(*((struct_matrice *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1][j - 1]
 									.partie_reelle;
 							(*((struct_complexe16 *) (*s_objet_elementaire)
 									.objet)).partie_imaginaire =
 									((struct_complexe16 **)
 									(*((struct_matrice *)
-									(*(((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]).objet))
+									(*((*(*s_etat_processus)
+									.pointeur_variable_courante).objet))
 									.objet)).tableau)[i - 1][j - 1]
 									.partie_imaginaire;
 						}
@@ -2333,9 +2307,8 @@ evaluation(struct_processus *s_etat_proc
 					 * Recherche de l'élément idoine dans la liste
 					 */
 
-					else if (((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == LST) &&
+					else if (((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == LST) &&
 							((*((struct_fonction *) (*(*l_element_courant)
 							.donnee).objet)).nombre_arguments == 1))
 					{
@@ -2346,10 +2319,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2382,10 +2354,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2415,9 +2386,8 @@ evaluation(struct_processus *s_etat_proc
 
 						liberation(s_etat_processus, s_objet_indice_i);
 
-						l_sous_element_courant = (*(((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)).objet;
+						l_sous_element_courant = (*((*(*s_etat_processus)
+								.pointeur_variable_courante).objet)).objet;
 						j = 0;
 
 						while(l_sous_element_courant != NULL)
@@ -2437,10 +2407,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2474,10 +2443,9 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2506,9 +2474,8 @@ evaluation(struct_processus *s_etat_proc
 					 * Recherche de l'élément idoine dans la table
 					 */
 
-					else if (((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == TAB) &&
+					else if (((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == TBL) &&
 							((*((struct_fonction *) (*(*l_element_courant)
 							.donnee).objet)).nombre_arguments == 1))
 					{
@@ -2519,10 +2486,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2555,10 +2521,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2589,19 +2554,17 @@ evaluation(struct_processus *s_etat_proc
 						liberation(s_etat_processus, s_objet_indice_i);
 
 						if ((i < 1) || (i > (integer8) (*((struct_tableau *)
-								(*((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]).objet)
+								(*(*(*s_etat_processus)
+								.pointeur_variable_courante).objet)
 								.objet)).nombre_elements))
 						{
 							free(s_objet_elementaire);
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2631,17 +2594,15 @@ evaluation(struct_processus *s_etat_proc
 
 						if ((s_objet_elementaire =
 								copie_objet(s_etat_processus,
-								(*((struct_tableau *) (*((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante]).objet)
+								(*((struct_tableau *) (*(*(*s_etat_processus)
+								.pointeur_variable_courante).objet)
 								.objet)).elements[i - 1], 'P')) == NULL)
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2665,23 +2626,18 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 					}
-					else if (((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == ALG) ||
-							((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == RPN))
+					else if (((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == ALG) ||
+							((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == RPN))
 					{
 						registre_evaluation_expression_compilee =
 								(*s_etat_processus)
 								.evaluation_expression_compilee;
 
-						if (((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante].origine == 'E') &&
-								((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus).position_variable_courante]
-								.niveau == 0))
+						if (((*(*s_etat_processus).pointeur_variable_courante)
+								.origine == 'E') && ((*(*s_etat_processus)
+								.pointeur_variable_courante).niveau == 0))
 						{
 							(*s_etat_processus).evaluation_expression_compilee =
 									'Y';
@@ -2692,9 +2648,8 @@ evaluation(struct_processus *s_etat_proc
 									'N';
 						}
 
-						if (evaluation(s_etat_processus, (*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante].objet,
+						if (evaluation(s_etat_processus, (*(*s_etat_processus)
+								.pointeur_variable_courante).objet,
 								type_evaluation) == d_erreur)
 						{
 							(*s_etat_processus).evaluation_expression_compilee =
@@ -2702,10 +2657,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2740,10 +2694,9 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2769,9 +2722,8 @@ evaluation(struct_processus *s_etat_proc
 							return(d_erreur);
 						}
 					}
-					else if ((*(((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet)).type == ADR)
+					else if ((*((*(*s_etat_processus)
+							.pointeur_variable_courante).objet)).type == ADR)
 					{
 						autorisation_empilement_programme = (*s_etat_processus)
 								.autorisation_empilement_programme;
@@ -2784,10 +2736,9 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(
 										&((*(*s_etat_processus)
@@ -2824,26 +2775,22 @@ evaluation(struct_processus *s_etat_proc
 
 						(*s_etat_processus).position_courante =
 								(*((unsigned long *)
-								((*((*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante]
-								.objet)).objet)));
+								((*(*(*s_etat_processus)
+								.pointeur_variable_courante).objet).objet)));
 
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
 							profilage(s_etat_processus,
-									(*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].nom);
+									(*(*s_etat_processus)
+									.pointeur_variable_courante).nom);
 
 							if ((*s_etat_processus).erreur_systeme != d_es)
 							{
 								if (presence_variable_partagee == d_vrai)
 								{
-									(*s_etat_processus).s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet
-											= NULL;
+									(*(*s_etat_processus)
+									 		.pointeur_variable_courante).objet =
+											NULL;
 
 									if (pthread_mutex_unlock(
 											&((*(*s_etat_processus)
@@ -2874,10 +2821,9 @@ evaluation(struct_processus *s_etat_proc
 
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
 										.s_liste_variables_partagees)
@@ -2912,10 +2858,9 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
 										.s_liste_variables_partagees)
@@ -2948,10 +2893,9 @@ evaluation(struct_processus *s_etat_proc
 						{
 							if (presence_variable_partagee == d_vrai)
 							{
-								(*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
-										= NULL;
+								(*(*s_etat_processus)
+								 		.pointeur_variable_courante).objet =
+										NULL;
 
 								if (pthread_mutex_unlock(&((*(*s_etat_processus)
 										.s_liste_variables_partagees).mutex))
@@ -2980,10 +2924,9 @@ evaluation(struct_processus *s_etat_proc
 					{
 						if (presence_variable_partagee == d_vrai)
 						{
-							(*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].objet
-									= NULL;
+							(*(*s_etat_processus)
+							 		.pointeur_variable_courante).objet =
+									NULL;
 
 							if (pthread_mutex_unlock(&((*(*s_etat_processus)
 									.s_liste_variables_partagees) .mutex)) != 0)
@@ -3013,10 +2956,9 @@ evaluation(struct_processus *s_etat_proc
 					{
 						if (presence_variable_partagee == d_vrai)
 						{
-							(*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].objet
-									= NULL;
+							(*(*s_etat_processus)
+							 		.pointeur_variable_courante).objet =
+									NULL;
 
 							if (pthread_mutex_unlock(&((*(*s_etat_processus)
 									.s_liste_variables_partagees).mutex)) != 0)
@@ -3038,10 +2980,8 @@ evaluation(struct_processus *s_etat_proc
 
 					if (presence_variable_partagee == d_vrai)
 					{
-						(*s_etat_processus).s_liste_variables
-								[(*s_etat_processus)
-								.position_variable_courante].objet
-								= NULL;
+						(*(*s_etat_processus)
+						 		.pointeur_variable_courante).objet = NULL;
 
 						if (pthread_mutex_unlock(&((*(*s_etat_processus)
 								.s_liste_variables_partagees).mutex)) != 0)
@@ -4002,7 +3942,7 @@ evaluation(struct_processus *s_etat_proc
 								{
 									/*
 									 * La fin de l'expression est atteinte,
-									 * le sequenceur reprend la main.
+									 * le séquenceur reprend la main.
 									 */
 
 									if (presence_egalite == d_vrai)
@@ -4383,14 +4323,42 @@ evaluation(struct_processus *s_etat_proc
 					{
 						(*s_etat_processus).erreur_systeme = d_es;
 						presence_variable = d_faux;
+
+						if ((*s_etat_processus).autorisation_nom_implicite
+								== 'N')
+						{
+							if ((*((struct_nom *) (*s_objet_elementaire).objet))
+									.symbole == d_faux)
+							{
+								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;
+
+								if (type_evaluation == 'I')
+								{
+									(*s_etat_processus)
+											.derniere_erreur_evaluation =
+											(*s_etat_processus)
+											.erreur_execution;
+								}
+							}
+						}
 					}
 					else
 					{
 						if ((*s_etat_processus).traitement_symbolique == 'N')
 						{
-							if ((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].objet == NULL)
+							if ((*(*s_etat_processus)
+									.pointeur_variable_courante).objet == NULL)
 							{
 								// Variable partagée
 
@@ -4406,13 +4374,10 @@ evaluation(struct_processus *s_etat_proc
 								presence_variable_partagee = d_faux;
 
 								if (recherche_variable_partagee(
-										s_etat_processus,
-										((*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante]).nom,
-										((*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante])
+										s_etat_processus, (*(*s_etat_processus)
+										.pointeur_variable_courante).nom,
+										(*(*s_etat_processus)
+										.pointeur_variable_courante)
 										.variable_partagee, 'E') == d_vrai)
 								{
 									presence_variable = d_vrai;
@@ -4490,11 +4455,9 @@ evaluation(struct_processus *s_etat_proc
 							{
 								presence_variable = d_vrai;
 
-								if ((*((*s_etat_processus)
-										.s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante]
-										.objet)).type == ADR)
+								if ((*(*(*s_etat_processus)
+										.pointeur_variable_courante).objet)
+										.type == ADR)
 								{
 									presence_fonction = d_vrai;
 								}
@@ -4510,123 +4473,157 @@ evaluation(struct_processus *s_etat_proc
 
 					if (presence_fonction == d_vrai)
 					{
-						autorisation_empilement_programme = (*s_etat_processus)
-								.autorisation_empilement_programme;
-						registre_position_courante = (*s_etat_processus)
-								.position_courante;
-
-						empilement_pile_systeme(s_etat_processus);
-
-						if ((*s_etat_processus).erreur_systeme != d_es)
+						if ((*((struct_nom *) (*(*l_element_courant).donnee)
+								.objet)).symbole == d_vrai)
 						{
-							if (presence_variable_partagee == d_vrai)
+							// 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,
+									(*l_element_courant).donnee, 'P')) == NULL)
 							{
-								liberation(s_etat_processus,
-										s_copie_variable_partagee);
+								(*s_etat_processus).instruction_courante =
+										instruction_courante;
+
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return(d_erreur);
 							}
 
-							if (presence_egalite == d_vrai)
+							if (empilement(s_etat_processus,
+									&((*s_etat_processus).l_base_pile),
+									s_sous_objet) == d_erreur)
 							{
-								liberation(s_etat_processus, s_objet_evalue);
+								(*s_etat_processus).instruction_courante =
+										instruction_courante;
+								liberation(s_etat_processus, s_sous_objet);
+								return(d_erreur);
 							}
-
-							(*s_etat_processus).instruction_courante =
-									instruction_courante;
-							return(d_erreur);
-						}
-
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.retour_definition = 'Y';
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.origine_routine_evaluation = 'Y';
-
-						(*s_etat_processus).mode_execution_programme = 'Y';
-						(*s_etat_processus).autorisation_empilement_programme
-								= 'N';
-
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.niveau_courant = (*s_etat_processus)
-								.niveau_courant;
-
-						if (presence_variable_partagee == d_faux)
-						{
-							(*s_etat_processus).position_courante =
-									(*((unsigned long *)
-									((*((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante]
-									.objet)).objet)));
 						}
 						else
 						{
-							(*s_etat_processus).position_courante =
-									(*((unsigned long *)
-									(*s_copie_variable_partagee).objet));
-							liberation(s_etat_processus,
-									s_copie_variable_partagee);
-						}
+							autorisation_empilement_programme =
+									(*s_etat_processus)
+									.autorisation_empilement_programme;
+							registre_position_courante = (*s_etat_processus)
+									.position_courante;
 
-						if ((*s_etat_processus).profilage == d_vrai)
-						{
-							profilage(s_etat_processus,
-									(*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].nom);
+							empilement_pile_systeme(s_etat_processus);
 
 							if ((*s_etat_processus).erreur_systeme != d_es)
 							{
+								if (presence_variable_partagee == d_vrai)
+								{
+									liberation(s_etat_processus,
+											s_copie_variable_partagee);
+								}
+
+								if (presence_egalite == d_vrai)
+								{
+									liberation(s_etat_processus,
+											s_objet_evalue);
+								}
+
+								(*s_etat_processus).instruction_courante =
+										instruction_courante;
 								return(d_erreur);
 							}
-						}
 
-						registre_evaluation_forcee =
-								(*s_etat_processus).evaluation_forcee;
+							(*(*s_etat_processus).l_base_pile_systeme)
+									.retour_definition = 'Y';
+							(*(*s_etat_processus).l_base_pile_systeme)
+									.origine_routine_evaluation = 'Y';
 
-						if (type_evaluation == 'N')
-						{
-							(*s_etat_processus).evaluation_forcee = 'Y';
-						}
+							(*s_etat_processus).mode_execution_programme = 'Y';
+							(*s_etat_processus)
+									.autorisation_empilement_programme = 'N';
 
-						if (sequenceur(s_etat_processus) == d_erreur)
-						{
-							(*s_etat_processus).evaluation_forcee =
-								registre_evaluation_forcee;
+							(*(*s_etat_processus).l_base_pile_systeme)
+									.niveau_courant = (*s_etat_processus)
+									.niveau_courant;
 
-							if (presence_egalite == d_vrai)
+							if (presence_variable_partagee == d_faux)
 							{
-								liberation(s_etat_processus, s_objet_evalue);
+								(*s_etat_processus).position_courante =
+										(*((unsigned long *)
+										((*(*(*s_etat_processus)
+										.pointeur_variable_courante)
+										.objet).objet)));
+							}
+							else
+							{
+								(*s_etat_processus).position_courante =
+										(*((unsigned long *)
+										(*s_copie_variable_partagee).objet));
+								liberation(s_etat_processus,
+										s_copie_variable_partagee);
 							}
 
+							if ((*s_etat_processus).profilage == d_vrai)
+							{
+								profilage(s_etat_processus,
+										(*(*s_etat_processus)
+										.pointeur_variable_courante).nom);
+
+								if ((*s_etat_processus).erreur_systeme != d_es)
+								{
+									return(d_erreur);
+								}
+							}
+
+							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);
+								}
+
+								(*s_etat_processus).instruction_courante =
+										instruction_courante;
+								(*s_etat_processus).mode_execution_programme =
+										registre_mode_execution_programme;
+								return(d_erreur);
+							}
+
+							(*s_etat_processus).evaluation_forcee =
+								registre_evaluation_forcee;
 							(*s_etat_processus).instruction_courante =
 									instruction_courante;
-							(*s_etat_processus).mode_execution_programme =
-									registre_mode_execution_programme;
-							return(d_erreur);
-						}
+							(*s_etat_processus).mode_execution_programme = 'N';
 
-						(*s_etat_processus).evaluation_forcee =
-							registre_evaluation_forcee;
-						(*s_etat_processus).instruction_courante =
-								instruction_courante;
-						(*s_etat_processus).mode_execution_programme = 'N';
-
-						depilement_pile_systeme(s_etat_processus);
+							depilement_pile_systeme(s_etat_processus);
 
-						if ((*s_etat_processus).erreur_systeme != d_es)
-						{
-							if (presence_egalite == d_vrai)
+							if ((*s_etat_processus).erreur_systeme != d_es)
 							{
-								liberation(s_etat_processus, s_objet_evalue);
+								if (presence_egalite == d_vrai)
+								{
+									liberation(s_etat_processus,
+											s_objet_evalue);
+								}
+
+								return(d_erreur);
 							}
 
-							return(d_erreur);
+							(*s_etat_processus).retour_routine_evaluation = 'N';
+							(*s_etat_processus).position_courante =
+									registre_position_courante;
+							(*s_etat_processus)
+									.autorisation_empilement_programme =
+									autorisation_empilement_programme;
 						}
-
-						(*s_etat_processus).retour_routine_evaluation = 'N';
-						(*s_etat_processus).position_courante =
-								registre_position_courante;
-						(*s_etat_processus).autorisation_empilement_programme =
-								autorisation_empilement_programme;
 					}
 					else if (((type_evaluation == 'N') || ((*((struct_nom *)
 							(*(*l_element_courant).donnee).objet)).symbole ==
@@ -4638,9 +4635,8 @@ evaluation(struct_processus *s_etat_proc
 							{
 								if ((s_sous_objet =
 										copie_objet(s_etat_processus,
-										(*s_etat_processus)
-										.s_liste_variables[(*s_etat_processus)
-										.position_variable_courante].objet,
+										(*(*s_etat_processus)
+										.pointeur_variable_courante).objet,
 										'P')) == NULL)
 								{
 									if (presence_variable_partagee == d_vrai)
@@ -4709,12 +4705,10 @@ evaluation(struct_processus *s_etat_proc
 									(*s_etat_processus)
 									.evaluation_expression_compilee;
 
-							if (((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].origine == 'E')
-									&& ((*s_etat_processus).s_liste_variables
-									[(*s_etat_processus)
-									.position_variable_courante].niveau == 0))
+							if (((*(*s_etat_processus)
+									.pointeur_variable_courante)
+									.origine == 'E') && ((*(*s_etat_processus)
+									.pointeur_variable_courante).niveau == 0))
 							{
 								(*s_etat_processus)
 										.evaluation_expression_compilee = 'Y';
@@ -4730,10 +4724,8 @@ evaluation(struct_processus *s_etat_proc
 								if ((*s_etat_processus).profilage == d_vrai)
 								{
 									profilage(s_etat_processus,
-											(*s_etat_processus)
-											.s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].nom);
+											(*(*s_etat_processus)
+											.pointeur_variable_courante).nom);
 
 									if ((*s_etat_processus).erreur_systeme
 										   	!= d_es)
@@ -4756,15 +4748,15 @@ evaluation(struct_processus *s_etat_proc
 								empilement_pile_systeme(s_etat_processus);
 
 								if (evaluation(s_etat_processus,
-										(*s_etat_processus)
-										.s_liste_variables[(*s_etat_processus)
-										.position_variable_courante].objet,
+										(*(*s_etat_processus)
+										.pointeur_variable_courante).objet,
 										type_evaluation) == d_erreur)
 								{
 									depilement_pile_systeme(s_etat_processus);
 
 									(*(*s_etat_processus).l_base_pile_systeme)
 											.niveau_courant =
+											registre_niveau_courant;
 									(*(*s_etat_processus).l_base_pile_systeme)
 											.retour_definition =
 											registre_retour_definition;
@@ -4795,6 +4787,7 @@ evaluation(struct_processus *s_etat_proc
 
 								(*(*s_etat_processus).l_base_pile_systeme)
 										.niveau_courant =
+										registre_niveau_courant;
 								(*(*s_etat_processus).l_base_pile_systeme)
 										.retour_definition =
 									   	registre_retour_definition;
@@ -4804,10 +4797,8 @@ evaluation(struct_processus *s_etat_proc
 								if ((*s_etat_processus).profilage == d_vrai)
 								{
 									profilage(s_etat_processus,
-											(*s_etat_processus)
-											.s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].nom);
+											(*(*s_etat_processus)
+											.pointeur_variable_courante).nom);
 
 									if ((*s_etat_processus).erreur_systeme
 										   	!= d_es)
@@ -4911,9 +4902,8 @@ evaluation(struct_processus *s_etat_proc
 									(*((struct_nom *) (*s_objet_elementaire)
 									.objet)).nom) == d_vrai)
 							{
-								if ((*s_etat_processus).s_liste_variables
-										[(*s_etat_processus)
-										.position_variable_courante].objet
+								if ((*(*s_etat_processus)
+										.pointeur_variable_courante).objet
 										== NULL)
 								{
 									// Variable partagée
@@ -4930,14 +4920,10 @@ evaluation(struct_processus *s_etat_proc
 
 									if (recherche_variable_partagee(
 											s_etat_processus,
-											((*s_etat_processus)
-											.s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante]).nom,
-											((*s_etat_processus)
-											.s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante])
+											(*(*s_etat_processus)
+											.pointeur_variable_courante).nom,
+											(*(*s_etat_processus)
+											.pointeur_variable_courante)
 											.variable_partagee, 'E') == d_vrai)
 									{
 										liberation(s_etat_processus,
@@ -4997,10 +4983,8 @@ evaluation(struct_processus *s_etat_proc
 
 									if ((s_objet_elementaire =
 											copie_objet(s_etat_processus,
-											(*s_etat_processus)
-											.s_liste_variables
-											[(*s_etat_processus)
-											.position_variable_courante].objet,
+											(*(*s_etat_processus)
+											.pointeur_variable_courante).objet,
 											'P')) == NULL)
 									{
 										if (presence_egalite == d_vrai)
@@ -5076,6 +5060,10 @@ 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
+						// symbolique.
+
 						if (presence_egalite == d_vrai)
 						{
 							liberation(s_etat_processus, s_objet_evalue);
@@ -5175,50 +5163,10 @@ evaluation(struct_processus *s_etat_proc
 
 			(*s_etat_processus).niveau_courant = niveau_initial;
 
-			for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
-			{
-				if ((*s_etat_processus).s_liste_variables[n].niveau
-						> niveau_initial)
-				{
-					m++;
-				}
-			}
-
-			registre_variables = (*s_etat_processus).s_liste_variables;
-			(*s_etat_processus).nombre_variables -= m;
-
-			if (((*s_etat_processus).s_liste_variables = malloc(
-					(*s_etat_processus).nombre_variables *
-					sizeof(struct_variable))) == NULL)
+			if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
 			{
-				if (presence_egalite == d_vrai)
-				{
-					liberation(s_etat_processus, s_objet_evalue);
-				}
-
-				(*s_etat_processus).instruction_courante = instruction_courante;
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return(d_erreur);
 			}
-
-			for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
-			{
-				if (registre_variables[n + m].niveau > niveau_initial)
-				{
-					free(registre_variables[n + m].nom);
-					liberation(s_etat_processus,
-							registre_variables[n + m].objet);
-					m++;
-					n--;
-				}
-				else
-				{
-					(*s_etat_processus).s_liste_variables[n] =
-							registre_variables[n + m];
-				}
-			}
-
-			free(registre_variables);
 		}
 
 		/*
@@ -5365,16 +5313,27 @@ evaluation(struct_processus *s_etat_proc
 		(*s_etat_processus).instruction_courante = 
 				(*((struct_fonction *) (*s_objet).objet)).nom_fonction;
 
+		registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
+				? 'E' : 'N';
+		cf(s_etat_processus, 35);
+
 		analyse(s_etat_processus, (*((struct_fonction *)
 				(*s_objet).objet)).fonction);
-
 		(*s_etat_processus).instruction_courante = instruction_courante;
 
+		if (registre_type_evaluation == 'E')
+		{
+			sf(s_etat_processus, 35);
+		}
+		else
+		{
+			cf(s_etat_processus, 35);
+		}
+
 		if (((*s_etat_processus).erreur_systeme != d_es) ||
 				((*s_etat_processus).erreur_execution != d_ex) ||
 				((*s_etat_processus).exception != d_ep))
 		{
-			(*s_etat_processus).instruction_courante = instruction_courante;
 			(*s_etat_processus).mode_execution_programme =
 					registre_mode_execution_programme;
 			return(d_erreur);
@@ -5382,18 +5341,18 @@ evaluation(struct_processus *s_etat_proc
 	}
 	else
 	{
+		(*s_etat_processus).instruction_courante = instruction_courante;
+
 		if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
 				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			(*s_etat_processus).instruction_courante = instruction_courante;
 			return(d_erreur);
 		}
 
 		if (empilement(s_etat_processus, &((*s_etat_processus)
 				.l_base_pile), s_objet_tampon) == d_erreur)
 		{
-			(*s_etat_processus).instruction_courante = instruction_courante;
 			return(d_erreur);
 		}
 	}