--- rpl/src/gestion_variables.c	2011/06/24 20:31:36	1.42
+++ rpl/src/gestion_variables.c	2012/10/03 14:53:11	1.58
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.4
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.11
+  Copyright (C) 1989-2012 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -426,6 +426,7 @@ ajout_variable(struct_processus *s_etat_
 		}
 
 		(*(*s_etat_processus).s_arbre_variables).feuille = NULL;
+		(*(*s_etat_processus).s_arbre_variables).feuille_statique = 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;
@@ -476,6 +477,9 @@ ajout_variable(struct_processus *s_etat_
 			(*(*l_variable_courante).noeuds[(*s_etat_processus)
 			 		.pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
 			(*(*l_variable_courante).noeuds[(*s_etat_processus)
+			 		.pointeurs_caracteres_variables[*ptr]]).feuille_statique
+					= 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
@@ -1292,7 +1296,8 @@ retrait_variable(struct_processus *s_eta
 					[(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
 					.feuille = NULL;
 
-			while((*s_arbre_courant).noeuds_utilises == 0)
+			while(((*s_arbre_courant).noeuds_utilises == 0) &&
+					((*s_arbre_courant).feuille_statique == NULL))
 			{
 				s_arbre_a_supprimer = s_arbre_courant;
 				s_arbre_courant = (*s_arbre_courant).noeud_pere;
@@ -1666,13 +1671,16 @@ void
 liberation_arbre_variables(struct_processus *s_etat_processus,
 		struct_arbre_variables *arbre, logical1 retrait_definitions)
 {
-	int						i;
+	int									i;
 
-	struct_liste_chainee	*l_element_courant_liste;
-	struct_liste_chainee	*l_element_suivant_liste;
+	struct_liste_chainee				*l_element_courant_liste;
+	struct_liste_chainee				*l_element_suivant_liste;
 
-	struct_liste_variables	*l_element_courant;
-	struct_liste_variables	*l_element_suivant;
+	struct_liste_variables				*l_element_courant;
+	struct_liste_variables				*l_element_suivant;
+
+	struct_liste_variables_statiques	*l_element_statique_courant;
+	struct_liste_variables_statiques	*l_element_statique_suivant;
 
 	// Libération de l'arbre des variables. Le contenu des variables n'est
 	// pas détruit par cette opération, il sera détruit lors de la libération
@@ -1697,6 +1705,19 @@ liberation_arbre_variables(struct_proces
 		(*arbre).feuille = NULL;
 	}
 
+	l_element_statique_courant = (*arbre).feuille_statique;
+
+	while(l_element_statique_courant != NULL)
+	{
+		l_element_statique_suivant = (*l_element_statique_courant).suivant;
+
+		free((*(*l_element_statique_courant).variable).nom);
+		liberation(s_etat_processus, (*(*l_element_statique_courant)
+				.variable).objet);
+
+		l_element_statique_courant = l_element_statique_suivant;
+	}
+
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
 	{
 		if ((*arbre).noeuds[i] != NULL)
@@ -1802,6 +1823,7 @@ nombre_variables(struct_processus *s_eta
 	return(n);
 }
 
+
 int
 liste_variables(struct_processus *s_etat_processus,
 		struct_tableau_variables *tableau, int position,
@@ -1845,6 +1867,7 @@ liste_variables(struct_processus *s_etat
 	return(position);
 }
 
+
 /*
 ================================================================================
   Procédure de copie de l'arbre des variables
@@ -1876,6 +1899,9 @@ copie_arbre_variables(struct_processus *
 
 	int								i;
 
+	logical1						niveau_0_traite;
+	logical1						niveau_1_traite;
+
 	struct_liste_chainee			*l_element_courant;
 
 	struct_liste_variables			*l_niveau_courant;
@@ -1888,7 +1914,7 @@ copie_arbre_variables(struct_processus *
 	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
+	// 0, s'il existe est le niveau précédent la valeur courante dans la
 	// boucle.
 
 	if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau
@@ -1900,59 +1926,72 @@ copie_arbre_variables(struct_processus *
 	// Les variables de niveaux 0 et 1 sont accessibles en au plus trois
 	// itérations (par construction).
 
+	niveau_0_traite = d_faux;
+	niveau_1_traite = d_faux;
+
 	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 (niveau_0_traite == d_faux)
 			{
-				if (ajout_variable(s_nouvel_etat_processus,
-						(struct_variable *) (*l_element_courant).donnee)
-						== d_erreur)
+				l_element_courant = (*l_niveau_courant).liste;
+
+				while(l_element_courant != NULL)
 				{
-					return;
+					if (ajout_variable(s_nouvel_etat_processus,
+							(struct_variable *) (*l_element_courant).donnee)
+							== d_erreur)
+					{
+						return;
+					}
+
+					l_element_courant = (*l_element_courant).suivant;
 				}
 
-				l_element_courant = (*l_element_courant).suivant;
+				niveau_0_traite = d_vrai;
 			}
 		}
 		else if ((*((struct_variable *) (*(*l_niveau_courant).liste)
 				.donnee)).niveau == 1)
 		{
-			l_element_courant = (*l_niveau_courant).liste;
-
-			while(l_element_courant != NULL)
+			if (niveau_1_traite == d_faux)
 			{
-				s_variable = (*((struct_variable *)
-						(*l_element_courant).donnee));
+				l_element_courant = (*l_niveau_courant).liste;
 
-				if ((s_variable.nom = strdup((*((struct_variable *)
-						(*l_element_courant).donnee)).nom)) == NULL)
+				while(l_element_courant != NULL)
 				{
-					(*s_nouvel_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
-					return;
-				}
+					s_variable = (*((struct_variable *)
+							(*l_element_courant).donnee));
 
-				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 ((s_variable.nom = strdup((*((struct_variable *)
+							(*l_element_courant).donnee)).nom)) == NULL)
+					{
+						(*s_nouvel_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
 
-				if (ajout_variable(s_nouvel_etat_processus, &s_variable)
-						== d_erreur)
-				{
-					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;
 				}
 
-				l_element_courant = (*l_element_courant).suivant;
+				niveau_1_traite = d_vrai;
 			}
 
 			// Les variables de niveau 0 ayant déjà été copiées, on