--- rpl/src/gestion_variables.c	2011/06/09 14:48:36	1.29
+++ rpl/src/gestion_variables.c	2011/06/21 07:45:22	1.37
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.0
+  RPL/2 (R) version 4.1.0.prerelease.1
   Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -25,13 +25,208 @@
 
 /*
 ================================================================================
+  Fonction de debug
+================================================================================
+  Entrée :
+--------------------------------------------------------------------------------
+  Sortie :
+--------------------------------------------------------------------------------
+  Effets de bords : néant
+================================================================================
+*/
+
+static void
+liste_variables_par_niveaux(struct_processus *s_etat_processus)
+{
+	int						c;
+
+	logical1				fin;
+
+	struct_liste_variables	*l;
+
+	struct_liste_chainee	*e;
+
+	printf("===========================================================\n");
+	printf("  Liste des variables par niveaux\n");
+	printf("===========================================================\n");
+
+	if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
+	{
+		printf("===========================================================\n");
+		return;
+	}
+
+	printf("Backward\n");
+	l = (*s_etat_processus).l_liste_variables_par_niveau;
+	c = 0;
+	fin = d_faux;
+
+	do
+	{
+		l = l->precedent;
+		e = l->liste;
+
+		while(e != NULL)
+		{
+			printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,
+					e->donnee, ((struct_variable *) e->donnee)->niveau);
+			e = e->suivant;
+			c++;
+			if (c > 100)
+			{
+				fin = d_vrai;
+				break;
+			}
+		}
+
+		printf("\n");
+
+	} while(l != (*s_etat_processus).l_liste_variables_par_niveau);
+
+	printf("Forward\n");
+	l = (*s_etat_processus).l_liste_variables_par_niveau;
+	c = 0;
+
+	do
+	{
+		e = l->liste;
+
+		while(e != NULL)
+		{
+			printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,
+					e->donnee, ((struct_variable *) e->donnee)->niveau);
+			e = e->suivant;
+			c++;
+			if (c > 100) exit(0);
+		}
+
+		printf("\n");
+
+		l = l->suivant;
+	} while(l != (*s_etat_processus).l_liste_variables_par_niveau);
+
+	printf("===========================================================\n");
+
+	if (fin == d_vrai) exit(0);
+
+	return;
+}
+
+static void
+liste_variables_tas(struct_processus *s_etat_processus,
+		struct_arbre_variables *arbre)
+{
+	int						c;
+	int						i;
+
+	logical1				fin;
+
+	struct_liste_variables	*l;
+
+	fin = d_faux;
+
+	if (arbre == NULL)
+	{
+		return;
+	}
+
+	printf(">>> Position :                  %d\n",
+			(*arbre).indice_tableau_pere);
+	printf(">>> Nombre de noeuds utilisés : %u\n",
+			(*arbre).noeuds_utilises);
+	printf(">>> Noeuds fils : ");
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*arbre).noeuds[i] != NULL)
+		{
+			printf("%d ", i);
+		}
+	}
+
+	printf("\b\n");
+
+	if ((*arbre).feuille != NULL)
+	{
+		printf("Feuille %p [%d]\n", (*arbre).feuille, (*arbre).noeuds_utilises);
+
+		printf("  Backward\n");
+
+		l = (*arbre).feuille;
+		c = 0;
+		fin = d_faux;
+
+		do
+		{
+			l = l->precedent;
+			c++;
+			if (c > 100)
+			{
+				fin = d_vrai;
+				break;
+			}
+			printf("    %s (%p, %d)\n", l->variable->nom, l->variable,
+					l->variable->niveau);
+		} while((*arbre).feuille != l);
+
+		printf("  Forward\n");
+
+		l = (*arbre).feuille;
+		c = 0;
+
+		do
+		{
+			c++;
+			if (c > 100) exit(0);
+			printf("    %s (%p, %d)\n", l->variable->nom, l->variable,
+					l->variable->niveau);
+			l = l->suivant;
+		} while((*arbre).feuille != l);
+	}
+
+	printf("-----------------------------------------------------------\n");
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*arbre).noeuds[i] != NULL)
+		{
+
+			liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]);
+		}
+	}
+
+	if (fin == d_vrai) exit(0);
+
+	return;
+}
+
+
+static void
+liste_variables_par_feuilles(struct_processus *s_etat_processus)
+{
+	printf("===========================================================\n");
+	printf("  Liste des variables sur le tas\n");
+	printf("===========================================================\n");
+
+	liste_variables_tas(s_etat_processus,
+			(*s_etat_processus).s_arbre_variables);
+
+	printf("===========================================================\n");
+
+	return;
+}
+
+
+/*
+================================================================================
   Routine de création d'une nouvelle variable
-  Entrée : autorisation_creation_variable_statique vaut 'V' ou 'S'.
-  Dans le cas 'V', la variable est volatile.
-  Dans le cas 'S', elle est statique.
-  Entrée : autorisation_creation_variable_partagee vaut 'P' ou 'S'.
-  Dans le cas 'P', la variable est privée.
-  Dans le cas 'S', elle est partagée.
+================================================================================
+  Entrée : autorisation_creation_variable_statique vaut 'v' ou 's'.
+  dans le cas 'v', la variable est volatile.
+  dans le cas 's', elle est statique.
+  Entrée : autorisation_creation_variable_partagee vaut 'p' ou 's'.
+  dans le cas 'p', la variable est privée.
+  dans le cas 's', elle est partagée.
 --------------------------------------------------------------------------------
   Sortie :
 --------------------------------------------------------------------------------
@@ -44,8 +239,11 @@ ajout_variable(struct_processus *s_etat_
 {
 	int							i;
 
+	logical1					niveau_acceptable;
+
 	struct_liste_variables		*l_nouvelle_variable;
 	struct_liste_variables		*l_variable_candidate;
+
 	struct_arbre_variables		*l_variable_courante;
 	struct_arbre_variables		*l_variable_precedente;
 
@@ -53,6 +251,8 @@ ajout_variable(struct_processus *s_etat_
 
 	unsigned char				*ptr;
 
+	void						*pointeur_variable_cree;
+
 	if ((*s_etat_processus).s_arbre_variables == NULL)
 	{
 		if (((*s_etat_processus).s_arbre_variables =
@@ -64,9 +264,10 @@ ajout_variable(struct_processus *s_etat_
 
 		(*(*s_etat_processus).s_arbre_variables).feuille = NULL;
 		(*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
+		(*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1;
 		(*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;
 
-		if (((*(*s_etat_processus).arbre_instructions).noeud =
+		if (((*(*s_etat_processus).s_arbre_variables).noeuds =
 				malloc((*s_etat_processus).nombre_caracteres_variables
 				* sizeof(struct_arbre_variables))) == NULL)
 		{
@@ -93,7 +294,8 @@ ajout_variable(struct_processus *s_etat_
 		if ((*l_variable_courante).noeuds[(*s_etat_processus)
 				.pointeurs_caracteres_variables[*ptr]] == NULL)
 		{
-			// Le noeud n'existe pas encore, on le crée.
+			// Le noeud n'existe pas encore, on le crée et on le marque
+			// comme utilisé dans la structure parente.
 
 			if (((*l_variable_courante).noeuds[(*s_etat_processus)
 					.pointeurs_caracteres_variables[*ptr]] =
@@ -104,13 +306,33 @@ ajout_variable(struct_processus *s_etat_
 			}
 
 			(*l_variable_courante).noeuds_utilises++;
+
+			// La feuille est par défaut vide et aucun élément du tableau noeuds
+			// (les branches qui peuvent être issues de ce nouveau noeud)
+			// n'est encore utilisée.
+
 			(*(*l_variable_courante).noeuds[(*s_etat_processus)
 			 		.pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
 			(*(*l_variable_courante).noeuds[(*s_etat_processus)
 			 		.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;
+
+			// Le champ noeud_pere de la structure créée pointe sur
+			// la structure parente et l'indice tableau_pere correspond à la
+			// position réelle dans le tableau noeuds[] de la structure parente
+			// du noeud courant. Cette valeur sera utilisée lors de la
+			// destruction du noeud pour annuler le pointeur contenu dans
+			// le tableau noeuds[] de la structure parente.
+
 			(*(*l_variable_courante).noeuds[(*s_etat_processus)
 			 		.pointeurs_caracteres_variables[*ptr]]).noeud_pere =
-					l_variable_precedente;
+					l_variable_courante;
+			(*(*l_variable_courante).noeuds[(*s_etat_processus)
+			 		.pointeurs_caracteres_variables[*ptr]])
+					.indice_tableau_pere = (*s_etat_processus)
+					.pointeurs_caracteres_variables[*ptr];
+
+			// Allocation du tableau noeuds[] et initialisation à zéro de
+			// tous les pointeurs.
 
 			if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
 					.pointeurs_caracteres_variables[*ptr]]).noeuds =
@@ -149,11 +371,14 @@ ajout_variable(struct_processus *s_etat_
 			return(d_erreur);
 		}
 
+		(*l_variable_courante).noeuds_utilises++;
+
 		(*(*l_variable_courante).feuille).suivant =
 				(*l_variable_courante).feuille;
 		(*(*l_variable_courante).feuille).precedent =
 				(*l_variable_courante).feuille;
 		(*(*l_variable_courante).feuille).noeud_pere = l_variable_precedente;
+		(*(*l_variable_courante).feuille).noeud = l_variable_courante;
 
 		// Allocation de la variable sur l'élément de la liste.
 
@@ -166,13 +391,7 @@ ajout_variable(struct_processus *s_etat_
 
 		(*((struct_variable *) (*(*l_variable_courante).feuille).variable)) =
 				(*s_variable);
-
-		if (((*((struct_variable *) (*(*l_variable_courante).feuille).variable))
-				.nom = strdup((*s_variable).nom)) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(d_erreur);
-		}
+		pointeur_variable_cree = (*(*l_variable_courante).feuille).variable;
 	}
 	else
 	{
@@ -201,6 +420,7 @@ ajout_variable(struct_processus *s_etat_
 			(*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille)
 					.precedent;
 			(*l_nouvelle_variable).noeud_pere = l_variable_precedente;
+			(*l_nouvelle_variable).noeud = l_variable_courante;
 			(*(*(*l_variable_courante).feuille).precedent).suivant =
 					l_nouvelle_variable;
 			(*(*l_variable_courante).feuille).precedent =
@@ -216,13 +436,7 @@ ajout_variable(struct_processus *s_etat_
 
 			(*((struct_variable *) (*(*l_variable_courante).feuille).variable))
 					= (*s_variable);
-
-			if (((*((struct_variable *) (*(*l_variable_courante).feuille)
-					.variable)).nom = strdup((*s_variable).nom)) == NULL)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-				return(d_erreur);
-			}
+			pointeur_variable_cree = (*(*l_variable_courante).feuille).variable;
 		}
 		else
 		{
@@ -244,13 +458,21 @@ ajout_variable(struct_processus *s_etat_
 			} while((l_variable_candidate != (*l_variable_courante).feuille) &&
 					((*(*l_variable_candidate).variable).niveau <= 1));
 
+			BUG((*s_variable).niveau == 0,
+					uprintf("Attempt to create a level-0 variable!\n"));
+
 			if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
 					.niveau > 1)
 			{
-				// Ajout inconditionnel des variables de niveaux 0 et 1
+				// La variable précédente est de niveau strictement supérieur
+				// à 1. Il ne peut donc y avoir aucune variable de niveau
+				// inférieur ou égal à 1 puisque la boucle est triée.
+				// On insère donc directement la variable en queue.
 			}
 			else
 			{
+				// Le niveau de la variable précédente dans la boucle est
+				// inférieur ou égal à 1.
 				l_variable_candidate = (*(*l_variable_courante).feuille)
 						.precedent;
 			}
@@ -259,9 +481,21 @@ ajout_variable(struct_processus *s_etat_
 			(*l_nouvelle_variable).precedent = (*l_variable_candidate)
 					.precedent;
 			(*l_nouvelle_variable).noeud_pere = l_variable_precedente;
+			(*l_nouvelle_variable).noeud = l_variable_courante;
 			(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
 			(*l_variable_candidate).precedent = l_nouvelle_variable;
 
+			// Si la variable suivant la variable que l'on vient d'insérer
+			// dans la boucle est de niveau 0, la variable insérée est par
+			// construction de niveau 1 et il convient de modifier le
+			// pointeur de feuille pointant sur l'élément de plus haut niveau
+			// de la boucle.
+
+			if ((*(*(*l_nouvelle_variable).precedent).variable).niveau == 0)
+			{
+				(*(*l_nouvelle_variable).noeud).feuille = l_nouvelle_variable;
+			}
+
 			if (((*l_nouvelle_variable).variable =
 					malloc(sizeof(struct_variable))) == NULL)
 			{ 
@@ -270,13 +504,7 @@ ajout_variable(struct_processus *s_etat_
 			}
 
 			(*(*l_nouvelle_variable).variable) = (*s_variable);
-
-			if (((*(*l_nouvelle_variable).variable).nom =
-					strdup((*s_variable).nom)) == NULL)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-				return(d_erreur);
-			}
+			pointeur_variable_cree = (*l_nouvelle_variable).variable;
 		}
 	}
 
@@ -298,8 +526,23 @@ ajout_variable(struct_processus *s_etat_
 		(*l_nouvelle_variable).suivant = l_nouvelle_variable;
 		(*l_nouvelle_variable).precedent = l_nouvelle_variable;
 		(*l_nouvelle_variable).noeud_pere = NULL;
+		(*l_nouvelle_variable).liste = NULL;
 
 		(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
+
+		// Ajout de la variable en tête de la liste
+
+		if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(d_erreur);
+		}
+
+		(*l_nouvel_element).suivant = (*(*s_etat_processus)
+				.l_liste_variables_par_niveau).liste;
+		(*l_nouvel_element).donnee = pointeur_variable_cree;
+		(*(*s_etat_processus).l_liste_variables_par_niveau).liste =
+				l_nouvel_element;
 	}
 	else if ((*s_variable).niveau > (*((struct_variable *)
 			(*(*(*s_etat_processus).l_liste_variables_par_niveau).liste)
@@ -319,62 +562,120 @@ ajout_variable(struct_processus *s_etat_
 		(*l_nouvelle_variable).precedent = (*(*s_etat_processus)
 				.l_liste_variables_par_niveau).precedent;
 		(*l_nouvelle_variable).noeud_pere = NULL;
+		(*l_nouvelle_variable).liste = NULL;
 		(*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent)
 				.suivant = l_nouvelle_variable;
-		(*(*s_etat_processus).l_liste_variables_par_niveau).precedent =
-				l_nouvelle_variable;
+		(*(*s_etat_processus).l_liste_variables_par_niveau)
+				.precedent = l_nouvelle_variable;
 
 		(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
-	}
-	else
-	{
-		// Création d'une variable de niveau 0 ou 1
 
-		if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
-				== NULL)
+		// Ajout de la variable en tête de la liste
+
+		if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(d_erreur);
 		}
 
+		(*l_nouvel_element).suivant = (*(*s_etat_processus)
+				.l_liste_variables_par_niveau).liste;
+		(*l_nouvel_element).donnee = pointeur_variable_cree;
+		(*(*s_etat_processus).l_liste_variables_par_niveau).liste =
+				l_nouvel_element;
+	}
+	else if ((*s_variable).niveau <= 1)
+	{
+		// Création d'une variable de niveau 0 ou 1. Il convient de
+		// chercher dans la liste si un niveau 0 ou 1 préexiste. Pour cela, on
+		// regarde la position courante et les deux précédentes.
+
 		l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;
+		niveau_acceptable = d_faux;
 
-		if ((*((struct_variable *) (*(*(*(*s_etat_processus)
-				.l_liste_variables_par_niveau).precedent).liste).donnee))
-				.niveau > 1)
+		for(i = 0; i <= 2; i++)
 		{
-			// Ajout inconditionnel des variables de niveaux 0 et 1
+			if ((*l_variable_candidate).liste == NULL)
+			{
+				continue;
+			}
+
+			if ((*((struct_variable *) (*(*l_variable_candidate)
+					.liste).donnee)).niveau == (*s_variable).niveau)
+			{
+				niveau_acceptable = d_vrai;
+				break;
+			}
+
+			l_variable_candidate = (*l_variable_candidate).precedent;
 		}
-		else
+
+		if (niveau_acceptable == d_faux)
+		{
+			if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(d_erreur);
+			}
+
+			l_variable_candidate =
+					(*(*s_etat_processus).l_liste_variables_par_niveau)
+					.precedent;
+
+			// On ne peut créer qu'une variable de niveau supérieur ou égal à
+			// 1 lors de l'exécution normale d'un programme. Les variables
+			// de niveau 0 sont créées à l'initialisation et relèvent du
+			// cas précédent car il n'existe lors de leur création aucun
+			// niveau non nul.
+
+			BUG((*s_variable).niveau == 0,
+					uprintf("Attempt to create a level-0 variable!\n"));
+
+			(*l_nouvelle_variable).suivant = l_variable_candidate;
+			(*l_nouvelle_variable).precedent = (*l_variable_candidate)
+					.precedent;
+			(*l_nouvelle_variable).noeud_pere = NULL;
+			(*l_nouvelle_variable).liste = NULL;
+			(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
+			(*l_variable_candidate).precedent = l_nouvelle_variable;
+
+			l_variable_candidate = l_nouvelle_variable;
+		}
+
+		// Ajout de la variable en tête de la liste l_variable_candidate.
+
+		if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
 		{
-			l_variable_candidate = (*(*s_etat_processus)
-					.l_liste_variables_par_niveau).precedent;
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(d_erreur);
 		}
 
-		(*l_nouvelle_variable).suivant = l_variable_candidate;
-		(*l_nouvelle_variable).precedent = (*l_variable_candidate)
-				.precedent;
-		(*l_nouvelle_variable).noeud_pere = NULL;
-		(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
-		(*l_variable_candidate).precedent = l_nouvelle_variable;
+		(*l_nouvel_element).suivant = (*l_variable_candidate).liste;
+		(*l_nouvel_element).donnee = pointeur_variable_cree;
+		(*l_variable_candidate).liste = l_nouvel_element;
 	}
+	else
+	{
+		// Ajout de la variable en tête de la liste
 
-	// Ajout de la variable en tête de la liste
+		if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(d_erreur);
+		}
 
-	if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(d_erreur);
+		(*l_nouvel_element).suivant = (*(*s_etat_processus)
+				.l_liste_variables_par_niveau).liste;
+		(*l_nouvel_element).donnee = pointeur_variable_cree;
+		(*(*s_etat_processus).l_liste_variables_par_niveau).liste =
+				l_nouvel_element;
 	}
 
-	(*l_nouvel_element).suivant = (*(*s_etat_processus)
-			.l_liste_variables_par_niveau).liste;
-	(*l_nouvel_element).donnee = (struct_objet *) s_variable;
-	(*l_nouvelle_variable).liste = l_nouvel_element;
-
 	return(d_absence_erreur);
 }
 
+
 logical1
 creation_variable(struct_processus *s_etat_processus,
 		struct_variable *s_variable,
@@ -527,7 +828,7 @@ recherche_variable(struct_processus *s_e
 	if ((*s_etat_processus).s_arbre_variables == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
-		return d_faux;
+		return(d_faux);
 	}
 
 	l_variable_courante = (*s_etat_processus).s_arbre_variables;
@@ -540,13 +841,16 @@ recherche_variable(struct_processus *s_e
 		if (pointeur < 0)
 		{
 			// Caractère hors de l'alphabet des variables
-			return(d_erreur);
+
+			(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
+			return(d_faux);
 		}
 
 		if ((*l_variable_courante).noeuds[pointeur] == NULL)
 		{
 			// Le chemin de la variable candidate n'existe pas.
-			return(d_erreur);
+			(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
+			return(d_faux);
 		}
 
 		l_variable_courante = (*l_variable_courante).noeuds[pointeur];
@@ -564,7 +868,7 @@ recherche_variable(struct_processus *s_e
 		{
 			// Problème : la pile système est vide !
 			(*s_etat_processus).erreur_systeme = d_es_pile_vide;
-			return(d_erreur);
+			return(d_faux);
 		}
 
 		while((*l_element_courant).retour_definition != 'Y')
@@ -574,7 +878,7 @@ recherche_variable(struct_processus *s_e
 			if (l_element_courant == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_pile_vide;
-				return(d_erreur);
+				return(d_faux);
 			}
 		}
 
@@ -589,7 +893,7 @@ recherche_variable(struct_processus *s_e
 					(*(*l_variable_courante).feuille).variable;
 			(*s_etat_processus).pointeur_feuille_courante =
 					(*l_variable_courante).feuille;
-			return(d_absence_erreur);
+			return(d_vrai);
 		}
 		else
 		{
@@ -606,29 +910,32 @@ recherche_variable(struct_processus *s_e
 				(*s_etat_processus).pointeur_variable_courante =
 						(*(*(*l_variable_courante).feuille).precedent).variable;
 				(*s_etat_processus).pointeur_feuille_courante =
-						(*l_variable_courante).feuille;
+						(*(*l_variable_courante).feuille).precedent;
 
 				// S'il existe une variable de niveau 0 et une seconde de
 				// niveau 1, la variable de niveau 0 (fonction) est masquée
 				// par celle de niveau 1.
 
-				if (((*(*(*l_variable_courante).feuille).variable).niveau == 0)
-						&& ((*(*(*(*l_variable_courante).feuille).precedent)
+				if (((*(*(*(*l_variable_courante).feuille).precedent)
+						.variable).niveau == 0) && ((*(*(*(*
+						(*l_variable_courante).feuille).precedent).precedent)
 						.variable).niveau == 1))
 				{
 					(*s_etat_processus).pointeur_variable_courante =
-							(*(*(*l_variable_courante).feuille).precedent)
-							.variable;
+							(*(*(*(*l_variable_courante).feuille).precedent)
+							.precedent).variable;
 					(*s_etat_processus).pointeur_feuille_courante =
-							(*l_variable_courante).feuille;
+							(*(*(*l_variable_courante).feuille).precedent)
+							.precedent;
 				}
 
-				return(d_absence_erreur);
+				return(d_vrai);
 			}
 		}
 	}
 
-	return(d_erreur);
+	(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
+	return(d_faux);
 }
 
 
@@ -646,9 +953,7 @@ recherche_variable_globale(struct_proces
 		{
 			case 0:
 			{
-				// Nous sommes en présence d'une définition et non d'une
-				// variable.
-
+				// La variable est une définition.
 				presence_variable = d_faux;
 				break;
 			}
@@ -722,6 +1027,7 @@ retrait_variable(struct_processus *s_eta
 		unsigned char *nom_variable, unsigned char type)
 {
 	logical1					erreur;
+	logical1					variable_supprimee;
 
 	struct_arbre_variables		*s_arbre_a_supprimer;
 	struct_arbre_variables		*s_arbre_courant;
@@ -734,6 +1040,8 @@ retrait_variable(struct_processus *s_eta
 
 	unsigned long				niveau;
 
+	(*s_etat_processus).niveau_supprime = d_faux;
+
 	if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)
 	{
 		// Une variable correspondant au nom recherché est accessible.
@@ -814,25 +1122,43 @@ retrait_variable(struct_processus *s_eta
 
 			variable_a_supprimer = (*s_etat_processus)
 					.pointeur_feuille_courante;
-			s_arbre_courant = (*variable_a_supprimer).noeud_pere;
-
+			//s_arbre_courant = (*variable_a_supprimer).noeud_pere;
+			s_arbre_courant = (*variable_a_supprimer).noeud;
 			BUG((*s_arbre_courant).noeuds_utilises == 0,
 					uprintf("Freed node !\n"));
 			(*s_arbre_courant).noeuds_utilises--;
 
+			(*((*(*variable_a_supprimer).noeud_pere).noeuds
+					[(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
+					.feuille = NULL;
+
 			while((*s_arbre_courant).noeuds_utilises == 0)
 			{
 				s_arbre_a_supprimer = s_arbre_courant;
 				s_arbre_courant = (*s_arbre_courant).noeud_pere;
 
-				free((*s_arbre_a_supprimer).noeuds);
-				free(s_arbre_a_supprimer);
-
 				if (s_arbre_courant == NULL)
 				{
+					free((*s_arbre_a_supprimer).noeuds);
+					free(s_arbre_a_supprimer);
+
+					(*s_etat_processus).s_arbre_variables = NULL;
 					break;
 				}
 
+				// s_arbre_a_supprimer contient la structure de feuille qui
+				// vient d'être libérée. Il s'agit maintenant
+				// d'annuler le pointeur dans le tableau noeuds de la structure
+				// pointée par noeud_pere, soit s_arbre_courant.
+
+				BUG((*s_arbre_a_supprimer).indice_tableau_pere < 0,
+						uprintf("Invalid pointer !\n"));
+				(*s_arbre_courant).noeuds[(*s_arbre_a_supprimer)
+						.indice_tableau_pere] = NULL;
+
+				free((*s_arbre_a_supprimer).noeuds);
+				free(s_arbre_a_supprimer);
+
 				BUG((*s_arbre_courant).noeuds_utilises == 0,
 						uprintf("Freed node !\n"));
 				(*s_arbre_courant).noeuds_utilises--;
@@ -852,6 +1178,26 @@ retrait_variable(struct_processus *s_eta
 			(*(*(*s_etat_processus).pointeur_feuille_courante).suivant)
 					.precedent = (*(*s_etat_processus)
 					.pointeur_feuille_courante).precedent;
+
+			// Mise à jour du pointeur dans l'arbre des variables. Cette
+			// mise à jour n'est nécessaire que dans le cas où la variable
+			// supprimée est en tête de la liste.
+
+			if (variable_a_supprimer == (*((*(*variable_a_supprimer).noeud_pere)
+					.noeuds[(*(*variable_a_supprimer).noeud)
+					.indice_tableau_pere])).feuille)
+			{
+				(*((*(*variable_a_supprimer).noeud_pere).noeuds
+						[(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
+						.feuille = (*(*((*(*variable_a_supprimer).noeud_pere)
+						.noeuds[(*(*variable_a_supprimer).noeud)
+						.indice_tableau_pere])).feuille).suivant;
+			}
+
+			(*s_etat_processus).pointeur_feuille_courante =
+					(*(*s_etat_processus).pointeur_feuille_courante).suivant;
+			(*s_etat_processus).pointeur_variable_courante =
+					(*(*s_etat_processus).pointeur_feuille_courante).variable;
 		}
 
 		// Dans tous les cas, on retire la variable de la liste des variables
@@ -859,55 +1205,101 @@ retrait_variable(struct_processus *s_eta
 
 		niveau = (*(*variable_a_supprimer).variable).niveau;
 		variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;
+		variable_supprimee = d_faux;
 
-		while(variables_par_niveau != NULL)
+		if (variables_par_niveau != NULL)
 		{
-			l_element_courant = (*variables_par_niveau).liste;
-
-			if (l_element_courant != NULL)
+			do
 			{
-				if ((*((struct_variable *) (*l_element_courant).donnee)).niveau
-						== niveau)
-				{
-					// On parcourt le bon niveau.
+				l_element_courant = (*variables_par_niveau).liste;
 
-					l_element_precedent = NULL;
-
-					while(l_element_courant != NULL)
+				if (l_element_courant != NULL)
+				{
+					if ((*((struct_variable *) (*l_element_courant).donnee))
+							.niveau == niveau)
 					{
-						// Tant que l_element_courant est non nul, il reste des
-						// variables à explorer dans le niveau courant.
+						// On parcourt le bon niveau.
+
+						l_element_precedent = NULL;
 
-						if ((*l_element_courant).donnee ==
-								(void *) (*variable_a_supprimer).variable)
+						while(l_element_courant != NULL)
 						{
-							// On a trouvé la variable à supprimer.
+							// Tant que l_element_courant est non nul, il reste
+							// des variables à explorer dans le niveau courant.
 
-							if (l_element_precedent == NULL)
-							{
-								(*variables_par_niveau).liste =
-										(*l_element_courant).suivant;
-							}
-							else
+							if ((*l_element_courant).donnee ==
+									(void *) (*variable_a_supprimer).variable)
 							{
-								(*l_element_precedent).suivant =
-										(*l_element_courant).suivant;
+								// On a trouvé la variable à supprimer.
+
+								if (l_element_precedent == NULL)
+								{
+									(*variables_par_niveau).liste =
+											(*l_element_courant).suivant;
+								}
+								else
+								{
+									(*l_element_precedent).suivant =
+											(*l_element_courant).suivant;
+								}
+
+								free(l_element_courant);
+
+								if ((*variables_par_niveau).liste == NULL)
+								{
+									(*s_etat_processus).niveau_supprime =
+											d_vrai;
+
+									if ((*s_etat_processus)
+											.l_liste_variables_par_niveau
+											== variables_par_niveau)
+									{
+										// On retire l'élément de la liste
+										// pointé par
+										// l_liste_variable_par_niveau
+
+										(*s_etat_processus)
+												.l_liste_variables_par_niveau =
+												(*variables_par_niveau).suivant;
+									}
+
+									(*(*variables_par_niveau).precedent)
+											.suivant =
+											(*variables_par_niveau).suivant;
+									(*(*variables_par_niveau).suivant)
+											.precedent =
+											(*variables_par_niveau)
+											.precedent;
+									free(variables_par_niveau);
+								}
+
+								variable_supprimee = d_vrai;
+								break;
 							}
-						}
 
-						l_element_precedent = l_element_courant;
-						l_element_courant = (*l_element_courant).suivant;
+							l_element_precedent = l_element_courant;
+							l_element_courant = (*l_element_courant).suivant;
+						}
 					}
 				}
-			}
 
-			variables_par_niveau = (*variables_par_niveau).suivant;
+				if (variable_supprimee == d_vrai)
+				{
+					break;
+				}
+
+				variables_par_niveau = (*variables_par_niveau).suivant;
+
+			} while(variables_par_niveau != (*s_etat_processus)
+					.l_liste_variables_par_niveau);
 		}
 
 		// Puis on libère le contenu de la variable.
 
 		free((*(*variable_a_supprimer).variable).nom);
 		liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet);
+		free((*variable_a_supprimer).variable);
+		free(variable_a_supprimer);
 
 		erreur = d_absence_erreur;
 	}
@@ -940,17 +1332,14 @@ retrait_variable(struct_processus *s_eta
 logical1
 retrait_variable_par_niveau(struct_processus *s_etat_processus)
 {
+	struct_liste_variables			*l_element_a_supprimer;
+
 	// Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.
 	// La tête de la pile contient toujours les variables de plus haut niveau
 	// créées.
 
-	struct_liste_variables			*l_niveau_suivant;
-
 	while((*s_etat_processus).l_liste_variables_par_niveau != NULL)
 	{
-		l_niveau_suivant = (*(*s_etat_processus).l_liste_variables_par_niveau)
-				.suivant;
-
 		if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL)
 		{
 			// Si le niveau ne contient aucune variable, on le détruit.
@@ -975,6 +1364,8 @@ retrait_variable_par_niveau(struct_proce
 			while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
 					!= NULL)
 			{
+				// Nécessaire car le pointeur sur la tête de la pile
+				// peut être modifié par retrait_variable().
 				// Sauvegarde des variables statiques.
 
 				if ((*((struct_variable *) (*(*(*s_etat_processus)
@@ -1062,11 +1453,32 @@ retrait_variable_par_niveau(struct_proce
 				{
 					return(d_erreur);
 				}
+
+				if ((*((struct_variable *) (*(*(*s_etat_processus)
+						.l_liste_variables_par_niveau).liste).donnee)).niveau
+						<= (*s_etat_processus).niveau_courant)
+				{
+					// On a retiré de l'arbre des variables toutes les
+					// variables de niveau strictement supérieur au niveau
+					// courant.
+
+					return(d_absence_erreur);
+				}
 			}
 		}
 
-		free((*s_etat_processus).l_liste_variables_par_niveau);
-		(*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;
+		// On retire l'élément de la liste doublement chaînée et circulaire.
+
+		(*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent).suivant
+				= (*(*s_etat_processus).l_liste_variables_par_niveau).suivant;
+		(*(*(*s_etat_processus).l_liste_variables_par_niveau).suivant).precedent
+				= (*(*s_etat_processus).l_liste_variables_par_niveau).precedent;
+
+		l_element_a_supprimer = (*s_etat_processus)
+				.l_liste_variables_par_niveau;
+		(*s_etat_processus).l_liste_variables_par_niveau =
+				(*l_element_a_supprimer).suivant;
+		free(l_element_a_supprimer);
 	}
 
 	return(d_absence_erreur);
@@ -1102,19 +1514,27 @@ liberation_arbre_variables(struct_proces
 	// pas détruit par cette opération, il sera détruit lors de la libération
 	// de la liste des variables par niveau.
 
+	if (arbre == NULL)
+	{
+		return;
+	}
+
+	l_element_courant = (*arbre).feuille;
+
+	if (l_element_courant != NULL)
+	{
+		do
+		{
+			l_element_suivant = (*l_element_courant).suivant;
+			free(l_element_courant);
+			l_element_courant = l_element_suivant;
+		} while(l_element_courant != (*arbre).feuille);
+	}
+
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
 	{
 		if ((*arbre).noeuds[i] != NULL)
 		{
-			l_element_courant = (*arbre).feuille;
-
-			while(l_element_courant != NULL)
-			{
-				l_element_suivant = (*l_element_courant).suivant;
-				free(l_element_courant);
-				l_element_courant = l_element_suivant;
-			}
-
 			liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
 					retrait_definitions);
 		}
@@ -1126,31 +1546,36 @@ liberation_arbre_variables(struct_proces
 	{
 		l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;
 
-		while(l_element_courant != NULL)
+		if (l_element_courant != NULL)
 		{
-			l_element_courant_liste = (*l_element_courant).liste;
-
-			while(l_element_courant_liste != NULL)
+			do
 			{
-				if ((retrait_definitions == d_vrai) ||
-						((*((struct_variable *) (*l_element_courant_liste)
-						.donnee)).niveau >= 1))
+				l_element_courant_liste = (*l_element_courant).liste;
+
+				while(l_element_courant_liste != NULL)
 				{
-					liberation(s_etat_processus, (*((struct_variable *)
-							(*l_element_courant_liste).donnee)).objet);
-					free((*((struct_variable *) (*l_element_courant_liste)
-							.donnee)).nom);
-					free((*l_element_courant_liste).donnee);
-				}
+					if ((retrait_definitions == d_vrai) ||
+							((*((struct_variable *) (*l_element_courant_liste)
+							.donnee)).niveau >= 1))
+					{
+						liberation(s_etat_processus, (*((struct_variable *)
+								(*l_element_courant_liste).donnee)).objet);
+						free((*((struct_variable *) (*l_element_courant_liste)
+								.donnee)).nom);
+						free((*l_element_courant_liste).donnee);
+					}
 
-				l_element_suivant_liste = (*l_element_courant_liste).suivant;
-				free(l_element_courant_liste);
-				l_element_courant_liste = l_element_suivant_liste;
-			}
+					l_element_suivant_liste =
+							(*l_element_courant_liste).suivant;
+					free(l_element_courant_liste);
+					l_element_courant_liste = l_element_suivant_liste;
+				}
 
-			l_element_suivant = (*l_element_courant).suivant;
-			free(l_element_courant);
-			l_element_courant = l_element_suivant;
+				l_element_suivant = (*l_element_courant).suivant;
+				free(l_element_courant);
+				l_element_courant = l_element_suivant;
+			} while(l_element_courant != (*s_etat_processus)
+					.l_liste_variables_par_niveau);
 		}
 	}
 
@@ -1163,6 +1588,95 @@ liberation_arbre_variables(struct_proces
 
 /*
 ================================================================================
+  Procédure renvoyant les variables dans un tableau
+================================================================================
+  Entrée :
+--------------------------------------------------------------------------------
+  Sortie :
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+int
+nombre_variables(struct_processus *s_etat_processus,
+		struct_arbre_variables *l_element_courant)
+{
+	int						i;
+	int						n;
+
+	struct_liste_variables	*l_variable;
+
+	n = 0;
+
+	if ((*l_element_courant).feuille != NULL)
+	{
+		l_variable = (*l_element_courant).feuille;
+
+		do
+		{
+			n++;
+			l_variable = (*l_variable).suivant;
+		} while(l_variable != (*l_element_courant).feuille);
+	}
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*l_element_courant).noeuds[i] != NULL)
+		{
+			n += nombre_variables(s_etat_processus,
+					(*l_element_courant).noeuds[i]);
+		}
+	}
+
+	return(n);
+}
+
+int
+liste_variables(struct_processus *s_etat_processus,
+		struct_tableau_variables *tableau, int position,
+		struct_arbre_variables *l_element_courant)
+{
+	int						i;
+
+	struct_liste_variables	*l_variable;
+
+	if ((*l_element_courant).feuille != NULL)
+	{
+		l_variable = (*l_element_courant).feuille;
+
+		do
+		{
+			tableau[position].origine = (*(*l_variable).variable).origine;
+			tableau[position].nom = (*(*l_variable).variable).nom;
+			tableau[position].niveau = (*(*l_variable).variable).niveau;
+			tableau[position].objet = (*(*l_variable).variable).objet;
+			tableau[position].variable_verrouillee =
+					(*(*l_variable).variable).variable_verrouillee;
+			tableau[position].variable_statique =
+					(*(*l_variable).variable).variable_statique;
+			tableau[position].variable_partagee =
+					(*(*l_variable).variable).variable_partagee;
+
+			position++;
+			l_variable = (*l_variable).suivant;
+		} while(l_variable != (*l_element_courant).feuille);
+	}
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*l_element_courant).noeuds[i] != NULL)
+		{
+			position = liste_variables(s_etat_processus,
+					tableau, position, (*l_element_courant).noeuds[i]);
+		}
+	}
+
+	return(position);
+}
+
+/*
+================================================================================
   Procédure de copie de l'arbre des variables
 ================================================================================
   Entrée :