--- rpl/src/gestion_variables.c	2011/08/09 11:31:30	1.46
+++ rpl/src/gestion_variables.c	2015/02/01 09:47:18	1.90
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.3
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.20
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -237,7 +237,7 @@ liste_variables_par_feuilles(struct_proc
 ================================================================================
 */
 
-static inline struct_arbre_variables *
+struct_arbre_variables *
 allocation_noeud(struct_processus *s_etat_processus)
 {
 	struct_arbre_variables			*objet;
@@ -272,7 +272,7 @@ liberation_noeud(struct_processus *s_eta
 	return;
 }
 
-static inline struct_arbre_variables **
+struct_arbre_variables **
 allocation_tableau_noeuds(struct_processus *s_etat_processus)
 {
 	struct_arbre_variables			**objet;
@@ -284,7 +284,8 @@ allocation_tableau_noeuds(struct_process
 	}
 	else
 	{
-		objet = malloc((*s_etat_processus).nombre_caracteres_variables
+		objet = malloc(((size_t) (*s_etat_processus)
+				.nombre_caracteres_variables)
 				* sizeof(struct_arbre_variables *));
 	}
 
@@ -426,12 +427,13 @@ 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;
 
 		if (((*(*s_etat_processus).s_arbre_variables).noeuds =
-					allocation_tableau_noeuds(s_etat_processus)) == NULL)
+				allocation_tableau_noeuds(s_etat_processus)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(d_erreur);
@@ -476,6 +478,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
@@ -984,7 +989,7 @@ recherche_variable(struct_processus *s_e
 
 	unsigned char				*ptr;
 
-	unsigned long				niveau_appel;
+	integer8					niveau_appel;
 
 	if ((*s_etat_processus).s_arbre_variables == NULL)
 	{
@@ -1199,7 +1204,7 @@ retrait_variable(struct_processus *s_eta
 	struct_liste_variables		*variable_a_supprimer;
 	struct_liste_variables		*variables_par_niveau;
 
-	unsigned long				niveau;
+	integer8					niveau;
 
 	(*s_etat_processus).niveau_supprime = d_faux;
 
@@ -1292,7 +1297,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;
@@ -1494,7 +1500,7 @@ retrait_variable(struct_processus *s_eta
 */
 
 logical1
-retrait_variable_par_niveau(struct_processus *s_etat_processus)
+retrait_variables_par_niveau(struct_processus *s_etat_processus)
 {
 	struct_liste_variables			*l_element_a_supprimer;
 
@@ -1525,6 +1531,15 @@ retrait_variable_par_niveau(struct_proce
 				break;
 			}
 
+			if (((*s_etat_processus).at_exit != NULL) &&
+					((*s_etat_processus).niveau_courant == 0))
+			{
+				// Il y a une routine ATEXIT enregistrée. On ne détruit pas
+				// les variables globales qui pourraient y être utilisées.
+
+				break;
+			}
+
 			while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
 					!= NULL)
 			{
@@ -1548,12 +1563,11 @@ retrait_variable_par_niveau(struct_proce
 								.l_liste_variables_par_niveau).liste).donnee))
 								.variable_statique, ((*s_etat_processus)
 								.mode_execution_programme
-								 == 'Y') ? 'P' : 'E') == d_vrai)
+								 == 'Y') ? 'P' : 'E') != NULL)
 						{
-							(*s_etat_processus).s_liste_variables_statiques
-									[(*s_etat_processus)
-									.position_variable_statique_courante]
-									.objet = (*((struct_variable *)
+							(*(*s_etat_processus)
+									.pointeur_variable_statique_courante)
+							 		.objet = (*((struct_variable *)
 									(*(*(*s_etat_processus)
 									.l_liste_variables_par_niveau).liste)
 									.donnee)).objet;
@@ -1587,11 +1601,10 @@ retrait_variable_par_niveau(struct_proce
 								.l_liste_variables_par_niveau).liste).donnee))
 								.variable_statique, ((*s_etat_processus)
 								.mode_execution_programme
-								 == 'Y') ? 'P' : 'E') == d_vrai)
+								 == 'Y') ? 'P' : 'E') != NULL)
 						{
-							(*s_etat_processus).s_liste_variables_statiques
-									[(*s_etat_processus)
-									.position_variable_statique_courante]
+							(*(*s_etat_processus)
+									.pointeur_variable_statique_courante)
 									.objet = (*((struct_variable *)
 									(*(*(*s_etat_processus)
 									.l_liste_variables_par_niveau).liste)
@@ -1666,13 +1679,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 +1713,21 @@ 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);
+		free((*l_element_statique_courant).variable);
+		free(l_element_statique_courant);
+
+		l_element_statique_courant = l_element_statique_suivant;
+	}
+
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
 	{
 		if ((*arbre).noeuds[i] != NULL)
@@ -1768,14 +1799,20 @@ liberation_arbre_variables(struct_proces
 ================================================================================
 */
 
-int
-nombre_variables(struct_processus *s_etat_processus,
+static integer8
+nombre_variables_locales(struct_processus *s_etat_processus,
 		struct_arbre_variables *l_element_courant)
 {
-	int						i;
-	int						n;
+	integer8							i;
+	integer8							n;
+
+	struct_liste_variables				*l_variable;
+	struct_liste_variables_statiques	*l_variable_statique;
 
-	struct_liste_variables	*l_variable;
+	if (l_element_courant == NULL)
+	{
+		return(0);
+	}
 
 	n = 0;
 
@@ -1790,11 +1827,29 @@ nombre_variables(struct_processus *s_eta
 		} while(l_variable != (*l_element_courant).feuille);
 	}
 
+	if ((*l_element_courant).feuille_statique != NULL)
+	{
+		l_variable_statique = (*l_element_courant).feuille_statique;
+
+		do
+		{
+			// Si le pointeur est nul, la variable est accessible et a été
+			// copiée dans l'arbre des variables.
+
+			if ((*(*l_variable_statique).variable).objet != NULL)
+			{
+				n++;
+			}
+
+			l_variable_statique = (*l_variable_statique).suivant;
+		} while(l_variable_statique != NULL);
+	}
+
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
 	{
 		if ((*l_element_courant).noeuds[i] != NULL)
 		{
-			n += nombre_variables(s_etat_processus,
+			n += nombre_variables_locales(s_etat_processus,
 					(*l_element_courant).noeuds[i]);
 		}
 	}
@@ -1802,14 +1857,114 @@ nombre_variables(struct_processus *s_eta
 	return(n);
 }
 
-int
-liste_variables(struct_processus *s_etat_processus,
-		struct_tableau_variables *tableau, int position,
+
+static integer8
+nombre_variables_partagees(struct_processus *s_etat_processus,
+		struct_arbre_variables_partagees *l_element_courant)
+{
+	integer8							i;
+	integer8							n;
+
+	struct_liste_variables_partagees	*l_variable;
+
+	if (l_element_courant == NULL)
+	{
+		return(0);
+	}
+
+	// Mutex deverrouillé par liste_variables_partagees();
+	if (pthread_mutex_lock(&((*l_element_courant).mutex_feuille)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(0);
+	}
+
+	n = 0;
+
+	if ((*l_element_courant).feuille != NULL)
+	{
+		l_variable = (*l_element_courant).feuille;
+
+		do
+		{
+			n++;
+			l_variable = (*l_variable).suivant;
+		} while(l_variable != NULL);
+	}
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*l_element_courant).noeuds[i] != NULL)
+		{
+			n += nombre_variables_partagees(s_etat_processus,
+					(*l_element_courant).noeuds[i]);
+		}
+	}
+
+	return(n);
+}
+
+
+integer8
+nombre_variables(struct_processus *s_etat_processus)
+{
+	return(nombre_variables_locales(s_etat_processus,
+			(*s_etat_processus).s_arbre_variables)
+			+ nombre_variables_partagees(s_etat_processus,
+			(*(*s_etat_processus).s_arbre_variables_partagees)));
+}
+
+
+void
+liberation_mutexes_arbre_variables_partagees(struct_processus *s_etat_processus,
+		struct_arbre_variables_partagees *l_element_courant)
+{
+	int									i;
+
+	if (l_element_courant == NULL)
+	{
+		return;
+	}
+
+	if (pthread_mutex_trylock(&((*l_element_courant).mutex_feuille)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
+
+	if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*l_element_courant).noeuds[i] != NULL)
+		{
+			liberation_mutexes_arbre_variables_partagees(s_etat_processus,
+					(*l_element_courant).noeuds[i]);
+		}
+	}
+
+	return;
+}
+
+
+static integer8
+liste_variables_locales(struct_processus *s_etat_processus,
+		struct_tableau_variables *tableau, integer8 position,
 		struct_arbre_variables *l_element_courant)
 {
-	int						i;
+	integer8							i;
+
+	struct_liste_variables				*l_variable;
+	struct_liste_variables_statiques	*l_variable_statique;
 
-	struct_liste_variables	*l_variable;
+	if (l_element_courant == NULL)
+	{
+		return(position);
+	}
 
 	if ((*l_element_courant).feuille != NULL)
 	{
@@ -1827,24 +1982,157 @@ liste_variables(struct_processus *s_etat
 					(*(*l_variable).variable).variable_statique;
 			tableau[position].variable_partagee =
 					(*(*l_variable).variable).variable_partagee;
+			tableau[position].variable_masquee = d_faux;
+			tableau[position].mutex = NULL;
 
 			position++;
+
 			l_variable = (*l_variable).suivant;
 		} while(l_variable != (*l_element_courant).feuille);
 	}
 
+	if ((*l_element_courant).feuille_statique != NULL)
+	{
+		l_variable_statique = (*l_element_courant).feuille_statique;
+
+		do
+		{
+			if ((*(*l_variable_statique).variable).objet != NULL)
+			{
+				tableau[position].origine = 'E';
+				tableau[position].nom = (*(*l_variable_statique).variable).nom;
+				tableau[position].niveau =
+						(*(*l_variable_statique).variable).niveau;
+				tableau[position].objet = (*(*l_variable_statique).variable)
+						.objet;
+				tableau[position].variable_verrouillee = d_faux;
+				tableau[position].variable_statique =
+						(*(*l_variable_statique).variable).variable_statique;
+				tableau[position].variable_partagee.pointeur = NULL;
+				tableau[position].variable_masquee = d_vrai;
+				tableau[position].mutex = NULL;
+
+				position++;
+			}
+
+			l_variable_statique = (*l_variable_statique).suivant;
+		} while(l_variable_statique != NULL);
+	}
+
+	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
+	{
+		if ((*l_element_courant).noeuds[i] != NULL)
+		{
+			position = liste_variables_locales(s_etat_processus,
+					tableau, position, (*l_element_courant).noeuds[i]);
+		}
+	}
+
+	return(position);
+}
+
+
+static integer8
+liste_variables_partagees(struct_processus *s_etat_processus,
+		struct_tableau_variables *tableau, integer8 position,
+		struct_arbre_variables_partagees *l_element_courant)
+{
+	integer8							i;
+
+	struct_liste_variables_partagees	*l_variable;
+
+	if (l_element_courant == NULL)
+	{
+		return(position);
+	}
+
+	if ((*l_element_courant).feuille != NULL)
+	{
+		l_variable = (*l_element_courant).feuille;
+
+		do
+		{
+			tableau[position].origine = 'E';
+			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 = d_faux;
+			tableau[position].variable_partagee =
+					(*(*l_variable).variable).variable_partagee;
+			tableau[position].variable_statique.pointeur = NULL;
+			tableau[position].variable_masquee = d_faux;
+			tableau[position].mutex = &((*(*l_variable).variable).mutex);
+			pthread_mutex_lock(tableau[position].mutex);
+
+			position++;
+
+			l_variable = (*l_variable).suivant;
+		} while(l_variable != NULL);
+	}
+
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
 	{
 		if ((*l_element_courant).noeuds[i] != NULL)
 		{
-			position = liste_variables(s_etat_processus,
+			position = liste_variables_partagees(s_etat_processus,
 					tableau, position, (*l_element_courant).noeuds[i]);
 		}
 	}
 
+	// Mutex verrouillé par nombre_variables_partagees();
+	if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(0);
+	}
+
 	return(position);
 }
 
+
+static int
+fonction_ordre_variables(const void *argument_1, const void *argument_2)
+{
+	int							comparaison;
+
+	struct_tableau_variables	*a1;
+	struct_tableau_variables	*a2;
+
+	a1 = (struct_tableau_variables *) argument_1;
+	a2 = (struct_tableau_variables *) argument_2;
+
+	comparaison = strcmp((*a1).nom, (*a2).nom);
+
+	if (comparaison != 0)
+	{
+		return(comparaison);
+	}
+	else
+	{
+		return(((((*a1).niveau - (*a2).niveau)) > 0) ? 1 : -1);
+	}
+}
+
+
+integer8
+liste_variables(struct_processus *s_etat_processus,
+		struct_tableau_variables *tableau)
+{
+	integer8		nombre_elements;
+
+	nombre_elements = liste_variables_locales(s_etat_processus,
+			tableau, 0, (*s_etat_processus).s_arbre_variables);
+	nombre_elements = liste_variables_partagees(s_etat_processus,
+			tableau, nombre_elements, (*(*s_etat_processus)
+			.s_arbre_variables_partagees));
+
+	qsort(tableau, (size_t) nombre_elements, sizeof(struct_tableau_variables),
+			fonction_ordre_variables);
+
+	return(nombre_elements);
+}
+
+
 /*
 ================================================================================
   Procédure de copie de l'arbre des variables
@@ -1874,13 +2162,22 @@ copie_arbre_variables(struct_processus *
 	// structure. Les variables de niveau 0 étant non modifiables, elles
 	// ne sont pas dupliquées.
 
-	int								i;
+	int									i;
+
+	logical1							niveau_0_traite;
+	logical1							niveau_1_traite;
 
-	struct_liste_chainee			*l_element_courant;
+	struct_arbre_variables				*l_variable_courante;
 
-	struct_liste_variables			*l_niveau_courant;
+	struct_liste_chainee				*l_element_courant;
 
-	struct_variable					s_variable;
+	struct_liste_variables				*l_niveau_courant;
+	struct_liste_variables_statiques	*l_element_statique_courant;
+
+	struct_variable						s_variable;
+	struct_variable_statique			s_variable_statique;
+
+	unsigned char						*ptr;
 
 	(*s_nouvel_etat_processus).s_arbre_variables = NULL;
 	(*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;
@@ -1888,7 +2185,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,69 +2197,244 @@ 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.nom = rpl_malloc(s_nouvel_etat_processus,
+							(strlen((*((struct_variable *)
+							(*l_element_courant).donnee)).nom) + 1) *
+							sizeof(unsigned char))) == NULL)
+					{
+						(*s_nouvel_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					strcpy(s_variable.nom, (*((struct_variable *)
+							(*l_element_courant).donnee)).nom);
+
+					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;
 				}
 
-				if ((s_variable.objet = copie_objet(s_nouvel_etat_processus,
-						(*((struct_variable *) (*l_element_courant).donnee))
-						.objet, 'P')) == NULL)
+				niveau_1_traite = d_vrai;
+			}
+
+			// 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;
+	}
+
+	// Copie des variables statiques
+
+	l_element_statique_courant = (*s_etat_processus)
+			.l_liste_variables_statiques;
+
+	while(l_element_statique_courant != NULL)
+	{
+		// Création des branches de l'arbre si nécessaire.
+
+		if ((*s_nouvel_etat_processus).s_arbre_variables == NULL)
+		{
+			if (((*s_nouvel_etat_processus).s_arbre_variables =
+						allocation_noeud(s_nouvel_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*s_nouvel_etat_processus).s_arbre_variables).feuille = NULL;
+			(*(*s_nouvel_etat_processus).s_arbre_variables).feuille_statique
+					= NULL;
+			(*(*s_nouvel_etat_processus).s_arbre_variables).noeuds_utilises = 0;
+			(*(*s_nouvel_etat_processus).s_arbre_variables).indice_tableau_pere
+					= -1;
+			(*(*s_nouvel_etat_processus).s_arbre_variables).noeud_pere = NULL;
+
+			if (((*(*s_nouvel_etat_processus).s_arbre_variables).noeuds =
+					allocation_tableau_noeuds(s_nouvel_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*s_nouvel_etat_processus)
+					.nombre_caracteres_variables; i++)
+			{
+				(*(*s_nouvel_etat_processus).s_arbre_variables).noeuds[i]
+						= NULL;
+			}
+		}
+
+		l_variable_courante = (*s_nouvel_etat_processus).s_arbre_variables;
+		ptr = (*(*l_element_statique_courant).variable).nom;
+
+		while((*ptr) != d_code_fin_chaine)
+		{
+			BUG((*s_nouvel_etat_processus).pointeurs_caracteres_variables
+					[*ptr] < 0, uprintf("Variable=\"%s\", (*ptr)='%c'\n",
+					(*(*l_element_statique_courant).variable).nom, *ptr));
+
+			if ((*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
+					.pointeurs_caracteres_variables[*ptr]] == NULL)
+			{
+				// 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_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]] =
+						allocation_noeud(s_nouvel_etat_processus)) == NULL)
 				{
-					(*s_nouvel_etat_processus).erreur_systeme =
+					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
 					return;
 				}
 
-				if (ajout_variable(s_nouvel_etat_processus, &s_variable)
-						== d_erreur)
+				(*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_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
+				(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]]).feuille_statique
+						= NULL;
+				(*(*l_variable_courante).noeuds[(*s_nouvel_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_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]]).noeud_pere =
+						l_variable_courante;
+				(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]])
+						.indice_tableau_pere = (*s_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr];
+
+				// Allocation du tableau noeuds[] et initialisation à zéro de
+				// tous les pointeurs.
+
+				if (((*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
+						.pointeurs_caracteres_variables[*ptr]]).noeuds =
+						allocation_tableau_noeuds(s_nouvel_etat_processus))
+						== NULL)
 				{
+					(*s_etat_processus).erreur_systeme
+							= d_es_allocation_memoire;
 					return;
 				}
 
-				l_element_courant = (*l_element_courant).suivant;
+				for(i = 0; i < (*s_nouvel_etat_processus)
+						.nombre_caracteres_variables; i++)
+				{
+					(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
+							.pointeurs_caracteres_variables[*ptr]]).noeuds[i]
+							= NULL;
+				}
 			}
 
-			// 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.
+			l_variable_courante = (*l_variable_courante).noeuds
+					[(*s_nouvel_etat_processus).pointeurs_caracteres_variables
+					[*ptr]];
 
-			break;
+			ptr++;
 		}
 
-		l_niveau_courant = (*l_niveau_courant).precedent;
+		// Il faut copier la variable pour la dissocier de la variable
+		// restant dans le thread parent.
+
+		s_variable_statique = (*(*l_element_statique_courant).variable);
+
+		if (copie_objet(s_etat_processus, s_variable_statique.objet, 'P')
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		if ((s_variable_statique.nom = rpl_malloc(s_nouvel_etat_processus,
+				(strlen((*(*l_element_statique_courant).variable).nom) + 1) *
+				sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		strcpy(s_variable_statique.nom, (*(*l_element_statique_courant)
+				.variable).nom);
+
+		if (creation_variable_statique(s_nouvel_etat_processus,
+				&s_variable_statique) == d_erreur)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		l_element_statique_courant = (*l_element_statique_courant).suivant;
 	}
 
 	return;
@@ -1982,7 +2454,7 @@ copie_arbre_variables(struct_processus *
 */
 
 /*
- * Caractères autorisés dans les instructions
+ * Caractères autorisés dans les variables
  *
  * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  * a b c d e f g h i j k l m n o p q r s t u v w x y z
@@ -2012,7 +2484,7 @@ initialisation_variables(struct_processu
 	}
 
 	if (((*s_etat_processus).pointeurs_caracteres_variables =
-			malloc(longueur_tableau * sizeof(int))) == NULL)
+			malloc(((size_t) longueur_tableau) * sizeof(int))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;