/*
================================================================================
  RPL/2 (R) version 4.1.0.prerelease.0
  Copyright (C) 1989-2011 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  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.
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bords : néant
================================================================================
*/

static logical1
ajout_variable(struct_processus *s_etat_processus, struct_variable *s_variable)
{
	int							i;

	struct_liste_variables		*l_nouvelle_variable;
	struct_liste_variables		*l_variable_candidate;
	struct_arbre_variables		*l_variable_courante;
	struct_arbre_variables		*l_variable_precedente;

	struct_liste_chainee		*l_nouvel_element;

	unsigned char				*ptr;

	if ((*s_etat_processus).s_arbre_variables == NULL)
	{
		if (((*s_etat_processus).s_arbre_variables =
				malloc(sizeof(struct_arbre_variables))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		(*(*s_etat_processus).s_arbre_variables).feuille = NULL;
		(*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
		(*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;

		if (((*(*s_etat_processus).arbre_instructions).noeud =
				malloc((*s_etat_processus).nombre_caracteres_variables
				* sizeof(struct_arbre_variables))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
		{
			(*(*s_etat_processus).s_arbre_variables).noeuds[i] = NULL;
		}
	}

	l_variable_precedente = NULL;
	l_variable_courante = (*s_etat_processus).s_arbre_variables;
	ptr = (*s_variable).nom;

	while((*ptr) != d_code_fin_chaine)
	{
		BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0,
				printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom,
				*ptr));

		if ((*l_variable_courante).noeuds[(*s_etat_processus)
				.pointeurs_caracteres_variables[*ptr]] == NULL)
		{
			// Le noeud n'existe pas encore, on le crée.

			if (((*l_variable_courante).noeuds[(*s_etat_processus)
					.pointeurs_caracteres_variables[*ptr]] =
					malloc(sizeof(struct_arbre_variables))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(d_erreur);
			}

			(*l_variable_courante).noeuds_utilises++;
			(*(*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;
			(*(*l_variable_courante).noeuds[(*s_etat_processus)
			 		.pointeurs_caracteres_variables[*ptr]]).noeud_pere =
					l_variable_precedente;

			if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
					.pointeurs_caracteres_variables[*ptr]]).noeuds =
					malloc((*s_etat_processus).nombre_caracteres_variables
					* sizeof(struct_arbre_variables))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(d_erreur);
			}

			for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
			{
				(*(*l_variable_courante).noeuds[(*s_etat_processus)
						.pointeurs_caracteres_variables[*ptr]]).noeuds[i]
						= NULL;
			}
		}

		l_variable_precedente = l_variable_courante;
		l_variable_courante = (*l_variable_courante).noeuds
				[(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];
		ptr++;
	}

	if ((*l_variable_courante).feuille == NULL)
	{
		// Aucune variable de même nom préexiste. On alloue le premier
		// élément de la liste doublement chaînée contenant toutes les
		// variables de même nom. Cette liste boucle en premier lieu sur
		// elle-même.

		if (((*l_variable_courante).feuille = malloc(
				sizeof(struct_liste_variables))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		(*(*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;

		// Allocation de la variable sur l'élément de la liste.

		if (((*(*l_variable_courante).feuille).variable =
				malloc(sizeof(struct_variable))) == NULL)
		{ 
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		(*((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);
		}
	}
	else
	{
		if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		if ((*s_variable).niveau > 1)
		{
			// Cas d'une variable locale

			// Si le niveau de la dernière variable de même nom est
			// supérieur au niveau de la variable locale que l'on veut
			// enregistrer dans la liste, cette liste est incohérente.

			BUG((*(*(*l_variable_courante).feuille).variable).niveau >=
					(*s_variable).niveau,
					printf("Variable=\"%s\"\n", (*s_variable).nom));

			// On ajoute la variable à la liste existante.

			(*l_nouvelle_variable).suivant = (*l_variable_courante).feuille;
			(*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille)
					.precedent;
			(*l_nouvelle_variable).noeud_pere = l_variable_precedente;
			(*(*(*l_variable_courante).feuille).precedent).suivant =
					l_nouvelle_variable;
			(*(*l_variable_courante).feuille).precedent =
					l_nouvelle_variable;
			(*l_variable_courante).feuille = l_nouvelle_variable;

			if (((*(*l_variable_courante).feuille).variable =
					malloc(sizeof(struct_variable))) == NULL)
			{ 
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(d_erreur);
			}

			(*((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);
			}
		}
		else
		{
			// Cas d'une variable globale (niveau 0 [définitions] ou 1
			// [variables globales])

			l_variable_candidate = (*l_variable_courante).feuille;

			do
			{
				// S'il y a déjà une variable de même niveau, la pile
				// est incohérente.

				BUG((*(*l_variable_candidate).variable).niveau ==
						(*s_variable).niveau,
						printf("Variable=\"%s\"\n", (*s_variable).nom));

				l_variable_candidate = (*l_variable_candidate).precedent;
			} while((l_variable_candidate != (*l_variable_courante).feuille) &&
					((*(*l_variable_candidate).variable).niveau <= 1));

			if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
					.niveau > 1)
			{
				// Ajout inconditionnel des variables de niveaux 0 et 1
			}
			else
			{
				l_variable_candidate = (*(*l_variable_courante).feuille)
						.precedent;
			}

			(*l_nouvelle_variable).suivant = l_variable_candidate;
			(*l_nouvelle_variable).precedent = (*l_variable_candidate)
					.precedent;
			(*l_nouvelle_variable).noeud_pere = l_variable_precedente;
			(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
			(*l_variable_candidate).precedent = l_nouvelle_variable;

			if (((*l_nouvelle_variable).variable =
					malloc(sizeof(struct_variable))) == NULL)
			{ 
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(d_erreur);
			}

			(*(*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);
			}
		}
	}

	// Ajout de la variable nouvellement créée à la liste par niveaux.
	// Le pointeur contenu dans la structure de description du processus indique
	// toujours le plus haut niveau utilisé.

	if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
	{
		// Le niveau courant n'existe pas. Il est créé.

		if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		(*l_nouvelle_variable).suivant = l_nouvelle_variable;
		(*l_nouvelle_variable).precedent = l_nouvelle_variable;
		(*l_nouvelle_variable).noeud_pere = NULL;

		(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
	}
	else if ((*s_variable).niveau > (*((struct_variable *)
			(*(*(*s_etat_processus).l_liste_variables_par_niveau).liste)
			.donnee)).niveau)
	{
		// Le niveau courant n'existe pas. Il est créé.

		if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return(d_erreur);
		}

		(*l_nouvelle_variable).suivant = (*s_etat_processus)
				.l_liste_variables_par_niveau;
		(*l_nouvelle_variable).precedent = (*(*s_etat_processus)
				.l_liste_variables_par_niveau).precedent;
		(*l_nouvelle_variable).noeud_pere = 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 = l_nouvelle_variable;
	}
	else
	{
		// Création d'une variable de niveau 0 ou 1

		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;

		if ((*((struct_variable *) (*(*(*(*s_etat_processus)
				.l_liste_variables_par_niveau).precedent).liste).donnee))
				.niveau > 1)
		{
			// Ajout inconditionnel des variables de niveaux 0 et 1
		}
		else
		{
			l_variable_candidate = (*(*s_etat_processus)
					.l_liste_variables_par_niveau).precedent;
		}

		(*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;
	}

	// 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 = (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,
		unsigned char autorisation_creation_variable_statique,
		unsigned char autorisation_creation_variable_partagee)
{
	if ((*s_etat_processus).mode_execution_programme == 'Y')
	{
		(*s_variable).origine = 'P';
	}
	else
	{
		(*s_variable).origine = 'E';
	}

	if ((*s_variable).niveau == 0)
	{
		// Un point d'entrée de définition est verrouillé.

		if ((*s_variable).origine == 'P')
		{
			(*s_variable).variable_statique.adresse = 0;
			(*s_variable).variable_partagee.adresse = 0;
		}
		else
		{
			(*s_variable).variable_statique.pointeur = NULL;
			(*s_variable).variable_partagee.pointeur = NULL;
		}

		(*s_variable).variable_verrouillee = d_vrai;
	}
	else if ((*s_variable).niveau == 1)
	{
		// Une variable globale ne peut être statique.

		if ((*s_variable).origine == 'P')
		{
			(*s_variable).variable_statique.adresse = 0;
			(*s_variable).variable_partagee.adresse = 0;
		}
		else
		{
			(*s_variable).variable_statique.pointeur = NULL;
			(*s_variable).variable_partagee.pointeur = NULL;
		}

		(*s_variable).variable_verrouillee = d_faux;
	}
	else
	{
		// 0 -> variable volatile
		// adresse de création -> variable statique

		if (autorisation_creation_variable_statique == 'V')
		{
			if (autorisation_creation_variable_partagee == 'S')
			{
				// On force la création d'une variable partagée

				if ((*s_variable).origine == 'P')
				{
					(*s_variable).variable_statique.adresse = 0;
					(*s_variable).variable_partagee.adresse =
							(*s_etat_processus).position_courante;
				}
				else
				{
					(*s_variable).variable_statique.pointeur = NULL;
					(*s_variable).variable_partagee.pointeur =
							(*s_etat_processus).objet_courant;
				}
			}
			else
			{
				// On force la création d'une variable volatile

				if ((*s_variable).origine == 'P')
				{
					(*s_variable).variable_statique.adresse = 0;
					(*s_variable).variable_partagee.adresse = 0;
				}
				else
				{
					(*s_variable).variable_statique.pointeur = NULL;
					(*s_variable).variable_partagee.pointeur = NULL;
				}
			}
		}
		else
		{
			// On force la création d'une variable statique.

			if ((*s_variable).origine == 'P')
			{
				(*s_variable).variable_statique.adresse =
						(*s_etat_processus).position_courante;
				(*s_variable).variable_partagee.adresse = 0;
			}
			else
			{
				(*s_variable).variable_statique.pointeur =
						(*s_etat_processus).objet_courant;
				(*s_variable).variable_partagee.pointeur = 0;
			}
		}

		(*s_variable).variable_verrouillee = d_faux;
	}

	/*
	 * Recherche de la feuille correspondante dans l'arbre des variables.
	 * Si cette feuille n'existe pas, elle est créée.
	 */

	if (ajout_variable(s_etat_processus, s_variable) == d_erreur)
	{
		return(d_erreur);
	}

	return(d_absence_erreur);
}


/*
================================================================================
  Procédure de recherche d'une variable par son nom dans la base
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

logical1
recherche_variable(struct_processus *s_etat_processus,
		unsigned char *nom_variable)
{
	int							pointeur;

	struct_arbre_variables		*l_variable_courante;
	struct_liste_pile_systeme	*l_element_courant;

	unsigned char				*ptr;

	unsigned long				niveau_appel;

	if ((*s_etat_processus).s_arbre_variables == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
		return d_faux;
	}

	l_variable_courante = (*s_etat_processus).s_arbre_variables;
	ptr = nom_variable;

	while((*ptr) != d_code_fin_chaine)
	{
		pointeur = (*s_etat_processus).pointeurs_caracteres_variables[*ptr];

		if (pointeur < 0)
		{
			// Caractère hors de l'alphabet des variables
			return(d_erreur);
		}

		if ((*l_variable_courante).noeuds[pointeur] == NULL)
		{
			// Le chemin de la variable candidate n'existe pas.
			return(d_erreur);
		}

		l_variable_courante = (*l_variable_courante).noeuds[pointeur];
		ptr++;
	}

	if ((*l_variable_courante).feuille != NULL)
	{
		// Il existe une pile de variables de même nom. Le sommet de la
		// pile est la variable de niveau le plus haut.

		l_element_courant = (*s_etat_processus).l_base_pile_systeme;

		if (l_element_courant == NULL)
		{
			// Problème : la pile système est vide !
			(*s_etat_processus).erreur_systeme = d_es_pile_vide;
			return(d_erreur);
		}

		while((*l_element_courant).retour_definition != 'Y')
		{
			l_element_courant = (*l_element_courant).suivant;

			if (l_element_courant == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_pile_vide;
				return(d_erreur);
			}
		}

		niveau_appel = (*l_element_courant).niveau_courant;

		if (niveau_appel < (*(*(*l_variable_courante).feuille).variable).niveau)
		{
			// Une variable locale est accessible puisque créée dans la
			// fonction courante.

			(*s_etat_processus).pointeur_variable_courante =
					(*(*l_variable_courante).feuille).variable;
			(*s_etat_processus).pointeur_feuille_courante =
					(*l_variable_courante).feuille;
			return(d_absence_erreur);
		}
		else
		{
			// Aucune variable locale n'est accessible depuis la fonction.
			// Dans ce cas, on prend la variable de niveau le plus bas
			// si ce niveau est inférieur ou égal à 1 (variable globale
			// ou fonction définie par l'utilisateur). Si le niveau de la
			// plus ancienne variable est strictement supérieur à 1, il
			// s'agit d'une variable locale inaccessible.

			if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
					.niveau <= 1)
			{
				(*s_etat_processus).pointeur_variable_courante =
						(*(*(*l_variable_courante).feuille).precedent).variable;
				(*s_etat_processus).pointeur_feuille_courante =
						(*l_variable_courante).feuille;

				// 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)
						.variable).niveau == 1))
				{
					(*s_etat_processus).pointeur_variable_courante =
							(*(*(*l_variable_courante).feuille).precedent)
							.variable;
					(*s_etat_processus).pointeur_feuille_courante =
							(*l_variable_courante).feuille;
				}

				return(d_absence_erreur);
			}
		}
	}

	return(d_erreur);
}


logical1
recherche_variable_globale(struct_processus *s_etat_processus,
		unsigned char *nom)
{
	logical1			presence_variable;

	presence_variable = recherche_variable(s_etat_processus, nom);

	if (presence_variable == d_vrai)
	{
		switch((*(*s_etat_processus).pointeur_variable_courante).niveau)
		{
			case 0:
			{
				// Nous sommes en présence d'une définition et non d'une
				// variable.

				presence_variable = d_faux;
				break;
			}

			case 1:
			{
				break;
			}

			default:
			{
				if ((*(*(*(*s_etat_processus).pointeur_feuille_courante)
						.precedent).variable).niveau == 1)
				{
					(*s_etat_processus).pointeur_feuille_courante =
							(*(*s_etat_processus).pointeur_feuille_courante)
							.precedent;
					(*s_etat_processus).pointeur_variable_courante =
							(*(*s_etat_processus).pointeur_feuille_courante)
							.variable;
				}
				else if ((*(*(*(*(*s_etat_processus).pointeur_feuille_courante)
						.precedent).precedent).variable).niveau == 1)
				{
					(*s_etat_processus).pointeur_feuille_courante =
							(*(*(*s_etat_processus).pointeur_feuille_courante)
							.precedent).precedent;
					(*s_etat_processus).pointeur_variable_courante =
							(*(*s_etat_processus).pointeur_feuille_courante)
							.variable;
				}
				else
				{
					presence_variable = d_faux;
				}

				break;
			}
		}
	}

	if (presence_variable == d_vrai)
	{
		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
		{
			// La variable n'est pas globale, elle est partagée.
			presence_variable = d_faux;
			(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
		}
	}

	return(presence_variable);
}


/*
================================================================================
  Procédure de retrait d'une variable de la base
================================================================================
  Entrée : type 'G' ou 'L' selon que l'on retire une variable locale (incluant
           les globales) ou strictement globale.
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

logical1
retrait_variable(struct_processus *s_etat_processus,
		unsigned char *nom_variable, unsigned char type)
{
	logical1					erreur;

	struct_arbre_variables		*s_arbre_a_supprimer;
	struct_arbre_variables		*s_arbre_courant;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_precedent;

	struct_liste_variables		*variable_a_supprimer;
	struct_liste_variables		*variables_par_niveau;

	unsigned long				niveau;

	if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)
	{
		// Une variable correspondant au nom recherché est accessible.

		if (type == 'G')
		{
			if ((*(*s_etat_processus).pointeur_variable_courante).niveau > 1)
			{
				// La variable obtenue est une variable locale. il faut
				// s'assurer qu'il existe une variable de niveau 1 de même
				// nom sur la feuille.

				if ((*(*(*(*s_etat_processus).pointeur_feuille_courante)
						.precedent).variable).niveau <= 1)
				{
					(*s_etat_processus).pointeur_feuille_courante =
							(*(*s_etat_processus).pointeur_feuille_courante)
							.precedent;
					(*s_etat_processus).pointeur_variable_courante =
							(*(*s_etat_processus).pointeur_feuille_courante)
							.variable;

					// Si la variable retournée est de niveau 0, on regarde
					// un peu plus loin si une variable de niveau 1 existe.

					if (((*(*(*s_etat_processus).pointeur_feuille_courante)
							.variable).niveau == 0) &&
							((*(*(*(*s_etat_processus)
							.pointeur_feuille_courante).precedent).variable)
							.niveau == 1))
					{
						(*s_etat_processus).pointeur_feuille_courante =
								(*(*s_etat_processus).pointeur_feuille_courante)
								.precedent;
						(*s_etat_processus).pointeur_variable_courante =
								(*(*s_etat_processus).pointeur_feuille_courante)
								.variable;
					}
				}
				else
				{
					// Aucune variable globale (niveau 1) n'existe.

					erreur = d_erreur;
					(*s_etat_processus).erreur_execution =
							d_ex_variable_non_definie;
					return(erreur);
				}
			}

			if ((*(*s_etat_processus).pointeur_variable_courante)
					.variable_verrouillee == d_vrai)
			{
				erreur = d_erreur;
				(*s_etat_processus).erreur_execution =
						d_ex_variable_verrouillee;
				return(erreur);
			}
		}

		// Suppression de la variable de la liste.
		// Deux cas peuvent survenir :
		// 1/ les pointeurs sur la variable et la variable suivante
		// sont identiques et on supprime la variable ainsi que la feuille
		// associée ;
		// 2/ ces deux pointeurs sont différents et se contente de retirer
		// la structure décrivant la variable.

		if ((*s_etat_processus).pointeur_feuille_courante ==
				(*(*s_etat_processus).pointeur_feuille_courante).suivant)
		{
			// Cas 1 :
			// On retire la variable du noeud en décrémentant le nombre
			// de feuilles de ce noeud. Si le nombre de feuilles du noeud
			// est nul, on retire les noeuds récursivement jusqu'à obtenir
			// un nombre non nul de feuilles utilisées (ou la racine des
			// variables).

			variable_a_supprimer = (*s_etat_processus)
					.pointeur_feuille_courante;
			s_arbre_courant = (*variable_a_supprimer).noeud_pere;

			BUG((*s_arbre_courant).noeuds_utilises == 0,
					uprintf("Freed node !\n"));
			(*s_arbre_courant).noeuds_utilises--;

			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)
				{
					break;
				}

				BUG((*s_arbre_courant).noeuds_utilises == 0,
						uprintf("Freed node !\n"));
				(*s_arbre_courant).noeuds_utilises--;
			}
		}
		else
		{
			// Cas 2 :
			// On retire la variable de la liste.

			variable_a_supprimer = (*s_etat_processus)
					.pointeur_feuille_courante;

			(*(*(*s_etat_processus).pointeur_feuille_courante).precedent)
					.suivant = (*(*s_etat_processus).pointeur_feuille_courante)
					.suivant;
			(*(*(*s_etat_processus).pointeur_feuille_courante).suivant)
					.precedent = (*(*s_etat_processus)
					.pointeur_feuille_courante).precedent;
		}

		// Dans tous les cas, on retire la variable de la liste des variables
		// par niveau.

		niveau = (*(*variable_a_supprimer).variable).niveau;
		variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;

		while(variables_par_niveau != NULL)
		{
			l_element_courant = (*variables_par_niveau).liste;

			if (l_element_courant != NULL)
			{
				if ((*((struct_variable *) (*l_element_courant).donnee)).niveau
						== niveau)
				{
					// On parcourt le bon niveau.

					l_element_precedent = NULL;

					while(l_element_courant != NULL)
					{
						// Tant que l_element_courant est non nul, il reste des
						// variables à explorer dans le niveau courant.

						if ((*l_element_courant).donnee ==
								(void *) (*variable_a_supprimer).variable)
						{
							// 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;
							}
						}

						l_element_precedent = l_element_courant;
						l_element_courant = (*l_element_courant).suivant;
					}
				}
			}

			variables_par_niveau = (*variables_par_niveau).suivant;
		}

		// Puis on libère le contenu de la variable.

		free((*(*variable_a_supprimer).variable).nom);
		liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet);

		erreur = d_absence_erreur;
	}
	else
	{
		// Aucune variable n'est accessible depuis le point courant du
		// programme.

		erreur = d_erreur;
		(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
	}

	return(erreur);
}


/*
================================================================================
  Procédure de retrait des variables de niveau strictement supérieur au
  niveau courant
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

logical1
retrait_variable_par_niveau(struct_processus *s_etat_processus)
{
	// 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.
			// Le pointeur sur la chaîne est déjà nul et il ne reste rien à
			// faire.
		}
		else
		{
			// Le niveau contient des variables.

			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.

				break;
			}

			while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
					!= NULL)
			{
				// Sauvegarde des variables statiques.

				if ((*((struct_variable *) (*(*(*s_etat_processus)
						.l_liste_variables_par_niveau).liste).donnee)).origine
						== 'P')
				{
					if ((*((struct_variable *) (*(*(*s_etat_processus)
							.l_liste_variables_par_niveau).liste).donnee))
							.variable_statique.adresse != 0)
					{
						if (recherche_variable_statique(s_etat_processus,
								(*((struct_variable *) (*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.nom, (*((struct_variable *)
								(*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.variable_statique, ((*s_etat_processus)
								.mode_execution_programme
								 == 'Y') ? 'P' : 'E') == d_vrai)
						{
							(*s_etat_processus).s_liste_variables_statiques
									[(*s_etat_processus)
									.position_variable_statique_courante]
									.objet = (*((struct_variable *)
									(*(*(*s_etat_processus)
									.l_liste_variables_par_niveau).liste)
									.donnee)).objet;
						}
						else
						{
							(*s_etat_processus).erreur_systeme =
									d_es_variable_introuvable;
						}

						(*((struct_variable *) (*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.objet = NULL;
					}
				}
				else
				{
					if ((*((struct_variable *) (*(*(*s_etat_processus)
							.l_liste_variables_par_niveau).liste).donnee))
							.variable_statique.pointeur != NULL)
					{
						/*
						 * Gestion des variables statiques
						 */

						if (recherche_variable_statique(s_etat_processus,
								(*((struct_variable *) (*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.nom, (*((struct_variable *)
								(*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.variable_statique, ((*s_etat_processus)
								.mode_execution_programme
								 == 'Y') ? 'P' : 'E') == d_vrai)
						{
							(*s_etat_processus).s_liste_variables_statiques
									[(*s_etat_processus)
									.position_variable_statique_courante]
									.objet = (*((struct_variable *)
									(*(*(*s_etat_processus)
									.l_liste_variables_par_niveau).liste)
									.donnee)).objet;
						}
						else
						{
							(*s_etat_processus).erreur_systeme =
									d_es_variable_introuvable;
							return(d_erreur);
						}

						(*((struct_variable *) (*(*(*s_etat_processus)
								.l_liste_variables_par_niveau).liste).donnee))
								.objet = NULL;
					}
				}

				if (retrait_variable(s_etat_processus,
						(*((struct_variable *) (*(*(*s_etat_processus)
						.l_liste_variables_par_niveau).liste).donnee)).nom,
						'L') == d_erreur)
				{
					return(d_erreur);
				}
			}
		}

		free((*s_etat_processus).l_liste_variables_par_niveau);
		(*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;
	}

	return(d_absence_erreur);
}


/*
================================================================================
  Procédure de retrait des toutes les variables locales et globales
================================================================================
  Entrée : drapeau indiquant s'il faut retirer les définitions (variables
           de niveau 0)
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
liberation_arbre_variables(struct_processus *s_etat_processus,
		struct_arbre_variables *arbre, logical1 retrait_definitions)
{
	int						i;

	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;

	// 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
	// de la liste des variables par niveau.

	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);
		}
	}

	// Suppression de la liste des variables par niveau.

	if (arbre == (*s_etat_processus).s_arbre_variables)
	{
		l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;

		while(l_element_courant != NULL)
		{
			l_element_courant_liste = (*l_element_courant).liste;

			while(l_element_courant_liste != NULL)
			{
				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 = (*l_element_courant).suivant;
			free(l_element_courant);
			l_element_courant = l_element_suivant;
		}
	}

	free((*arbre).noeuds);
	free(arbre);

	return;
}


/*
================================================================================
  Procédure de copie de l'arbre des variables
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

struct_arbre_variables *
copie_arbre_variables(struct_processus *s_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.

	BUG(1, uprintf("Oops !\n"));

	return(d_absence_erreur);
}


/*
================================================================================
  Procédure d'initialisation de la table de correspondance des variables
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

/*
 * Caractères autorisés dans les instructions
 *
 * 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
 * _
 * 1 2 3 4 5 6 7 8 9 0
 */

void
initialisation_variables(struct_processus *s_etat_processus)
{
	int				decalage;
	int				i;
	int				longueur_tableau;

	unsigned char	caractere;

	// Récupération de la longueur d'un unsigned char

	longueur_tableau = 1;
	decalage = 0;
	caractere = 1;

	while((1L << decalage) == (long) ((unsigned char) (caractere << decalage)))
	{
		decalage++;
		longueur_tableau *= 2;
	}

	if (((*s_etat_processus).pointeurs_caracteres_variables =
			malloc(longueur_tableau * sizeof(int))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	for(i = 0; i < longueur_tableau; i++)
	{
		(*s_etat_processus).pointeurs_caracteres_variables[i] = -1;
	}

	(*s_etat_processus).nombre_caracteres_variables = 0;

#define DECLARATION_CARACTERE(c) \
		do { (*s_etat_processus).pointeurs_caracteres_variables[c] = \
		(*s_etat_processus).nombre_caracteres_variables++; } while(0)

	DECLARATION_CARACTERE('A');
	DECLARATION_CARACTERE('B');
	DECLARATION_CARACTERE('C');
	DECLARATION_CARACTERE('D');
	DECLARATION_CARACTERE('E');
	DECLARATION_CARACTERE('F');
	DECLARATION_CARACTERE('G');
	DECLARATION_CARACTERE('H');
	DECLARATION_CARACTERE('I');
	DECLARATION_CARACTERE('J');
	DECLARATION_CARACTERE('K');
	DECLARATION_CARACTERE('L');
	DECLARATION_CARACTERE('M');
	DECLARATION_CARACTERE('N');
	DECLARATION_CARACTERE('O');
	DECLARATION_CARACTERE('P');
	DECLARATION_CARACTERE('Q');
	DECLARATION_CARACTERE('R');
	DECLARATION_CARACTERE('S');
	DECLARATION_CARACTERE('T');
	DECLARATION_CARACTERE('U');
	DECLARATION_CARACTERE('V');
	DECLARATION_CARACTERE('W');
	DECLARATION_CARACTERE('X');
	DECLARATION_CARACTERE('Y');
	DECLARATION_CARACTERE('Z');

	DECLARATION_CARACTERE('a');
	DECLARATION_CARACTERE('b');
	DECLARATION_CARACTERE('c');
	DECLARATION_CARACTERE('d');
	DECLARATION_CARACTERE('e');
	DECLARATION_CARACTERE('f');
	DECLARATION_CARACTERE('g');
	DECLARATION_CARACTERE('h');
	DECLARATION_CARACTERE('i');
	DECLARATION_CARACTERE('j');
	DECLARATION_CARACTERE('k');
	DECLARATION_CARACTERE('l');
	DECLARATION_CARACTERE('m');
	DECLARATION_CARACTERE('n');
	DECLARATION_CARACTERE('o');
	DECLARATION_CARACTERE('p');
	DECLARATION_CARACTERE('q');
	DECLARATION_CARACTERE('r');
	DECLARATION_CARACTERE('s');
	DECLARATION_CARACTERE('t');
	DECLARATION_CARACTERE('u');
	DECLARATION_CARACTERE('v');
	DECLARATION_CARACTERE('w');
	DECLARATION_CARACTERE('x');
	DECLARATION_CARACTERE('y');
	DECLARATION_CARACTERE('z');

	DECLARATION_CARACTERE('_');

	DECLARATION_CARACTERE('1');
	DECLARATION_CARACTERE('2');
	DECLARATION_CARACTERE('3');
	DECLARATION_CARACTERE('4');
	DECLARATION_CARACTERE('5');
	DECLARATION_CARACTERE('6');
	DECLARATION_CARACTERE('7');
	DECLARATION_CARACTERE('8');
	DECLARATION_CARACTERE('9');
	DECLARATION_CARACTERE('0');
#undef DECLARATION_CARACTERE

	return;
}

// vim: ts=4