--- rpl/src/gestion_variables.c	2011/06/17 07:55:59	1.31
+++ rpl/src/gestion_variables.c	2011/06/21 15:03:58	1.38
@@ -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,216 @@
 
 /*
 ================================================================================
+  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->%p, %d) ", ((struct_variable *) e->donnee)->nom,
+					e, 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->%p, %d) ", ((struct_variable *) e->donnee)->nom,
+					e, 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 +247,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;
 
@@ -173,11 +379,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.
 
@@ -219,6 +428,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 =
@@ -256,13 +466,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;
 			}
@@ -271,9 +489,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)
 			{ 
@@ -307,6 +537,20 @@ ajout_variable(struct_processus *s_etat_
 		(*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)
@@ -329,54 +573,112 @@ ajout_variable(struct_processus *s_etat_
 		(*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 if ((*s_variable).niveau <= 1)
-	{
-		// 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++)
 		{
-			l_variable_candidate = (*(*s_etat_processus)
-					.l_liste_variables_par_niveau).precedent;
+			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;
 		}
 
-		(*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;
-	}
+		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);
+			}
 
-	// Ajout de la variable en tête de la liste
+			l_variable_candidate =
+					(*(*s_etat_processus).l_liste_variables_par_niveau)
+					.precedent;
 
-	if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(d_erreur);
+			// 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)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(d_erreur);
+		}
+
+		(*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
 
-	(*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;
+		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;
+	}
 
 	return(d_absence_erreur);
 }
@@ -616,21 +918,23 @@ 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_vrai);
@@ -657,9 +961,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;
 			}
@@ -733,6 +1035,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;
@@ -745,6 +1048,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.
@@ -825,12 +1130,15 @@ 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;
 			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;
@@ -840,6 +1148,8 @@ retrait_variable(struct_processus *s_eta
 				{
 					free((*s_arbre_a_supprimer).noeuds);
 					free(s_arbre_a_supprimer);
+
+					(*s_etat_processus).s_arbre_variables = NULL;
 					break;
 				}
 
@@ -875,6 +1185,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
@@ -882,6 +1212,7 @@ 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;
 
 		if (variables_par_niveau != NULL)
 		{
@@ -920,6 +1251,36 @@ retrait_variable(struct_processus *s_eta
 								}
 
 								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;
 							}
 
@@ -929,6 +1290,11 @@ retrait_variable(struct_processus *s_eta
 					}
 				}
 
+				if (variable_supprimee == d_vrai)
+				{
+					break;
+				}
+
 				variables_par_niveau = (*variables_par_niveau).suivant;
 
 			} while(variables_par_niveau != (*s_etat_processus)
@@ -939,6 +1305,8 @@ retrait_variable(struct_processus *s_eta
 
 		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;
 	}
@@ -1003,6 +1371,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)
@@ -1090,6 +1460,17 @@ 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);
+				}
 			}
 		}
 
@@ -1140,6 +1521,11 @@ 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)
@@ -1150,6 +1536,8 @@ liberation_arbre_variables(struct_proces
 			free(l_element_courant);
 			l_element_courant = l_element_suivant;
 		} while(l_element_courant != (*arbre).feuille);
+
+		(*arbre).feuille = NULL;
 	}
 
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
@@ -1158,6 +1546,7 @@ liberation_arbre_variables(struct_proces
 		{
 			liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
 					retrait_definitions);
+			(*arbre).noeuds[i] = NULL;
 		}
 	}
 
@@ -1183,11 +1572,11 @@ liberation_arbre_variables(struct_proces
 								(*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).donnee);
 					free(l_element_courant_liste);
 					l_element_courant_liste = l_element_suivant_liste;
 				}
@@ -1202,6 +1591,7 @@ liberation_arbre_variables(struct_proces
 
 	free((*arbre).noeuds);
 	free(arbre);
+	arbre = NULL;
 
 	return;
 }
@@ -1209,6 +1599,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 :
@@ -1219,19 +1698,115 @@ liberation_arbre_variables(struct_proces
 ================================================================================
 */
 
-struct_arbre_variables *
-copie_arbre_variables(struct_processus *s_etat_processus)
+void
+copie_arbre_variables(struct_processus *s_etat_processus, struct_processus
+		*s_nouvel_etat_processus)
 {
 	// Les définitions sont partagées entre tous les threads et ne sont pas
 	// copiées.
 	//
 	// NB : on ne copie que les variables de niveaux 0 et 1, les autres
 	// variables locales étant masquées par le processus de création de thread
-	// ou de processus, elles sont inaccessibles.
+	// ou de processus, elles seront inaccessibles de tous les points
+	// du fil d'exécution fils.
 
-	BUG(1, uprintf("Oops !\n"));
+	// Pour copier ces variables, on récupère les variables depuis la liste par
+	// niveaux (niveaux 0 et 1) et on ajoute les variables dans la nouvelle
+	// structure. Les variables de niveau 0 étant non modifiables, elles
+	// ne sont pas dupliquées.
 
-	return(d_absence_erreur);
+	int								i;
+
+	struct_liste_chainee			*l_element_courant;
+
+	struct_liste_variables			*l_niveau_courant;
+
+	struct_variable					s_variable;
+
+	(*s_nouvel_etat_processus).s_arbre_variables = NULL;
+	(*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;
+
+	l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau;
+	
+	// Si la variable en tête n'est pas une variable de niveau 0, le niveau
+	// 0, s'il existe est le nivau précédent la valeur courante dans la
+	// boucle.
+
+	if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau
+			!= 0)
+	{
+		l_niveau_courant = (*l_niveau_courant).precedent;
+	}
+
+	// Les variables de niveaux 0 et 1 sont accessibles en au plus trois
+	// itérations (par construction).
+
+	for(i = 0; i <= 2; i++)
+	{
+		if ((*((struct_variable *) (*(*l_niveau_courant).liste)
+				.donnee)).niveau == 0)
+		{
+			l_element_courant = (*l_niveau_courant).liste;
+
+			while(l_element_courant != NULL)
+			{
+				if (ajout_variable(s_nouvel_etat_processus,
+						(struct_variable *) (*l_element_courant).donnee)
+						== d_erreur)
+				{
+					return;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+		}
+		else if ((*((struct_variable *) (*(*l_niveau_courant).liste)
+				.donnee)).niveau == 1)
+		{
+			l_element_courant = (*l_niveau_courant).liste;
+
+			while(l_element_courant != NULL)
+			{
+				s_variable = (*((struct_variable *)
+						(*l_element_courant).donnee));
+
+				if ((s_variable.nom = strdup((*((struct_variable *)
+						(*l_element_courant).donnee)).nom)) == NULL)
+				{
+					(*s_nouvel_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if ((s_variable.objet = copie_objet(s_nouvel_etat_processus,
+						(*((struct_variable *) (*l_element_courant).donnee))
+						.objet, 'P')) == NULL)
+				{
+					(*s_nouvel_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (ajout_variable(s_nouvel_etat_processus, &s_variable)
+						== d_erreur)
+				{
+					return;
+				}
+
+				l_element_courant = (*l_element_courant).suivant;
+			}
+
+			// Les variables de niveau 0 ayant déjà été copiées, on
+			// peut sortir de la boucle car toutes les variables sont
+			// maintenant disponibles dans le fil d'exécution fils.
+
+			break;
+		}
+
+		l_niveau_courant = (*l_niveau_courant).precedent;
+	}
+
+	return;
 }