/*
================================================================================
  RPL/2 (R) version 4.1.19
  Copyright (C) 1989-2015 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 retrait des variables statiques
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bords : néant
================================================================================
*/

// Cette routine libère toutes les variables statiques de niveau non
// nul, donc attachées à une expression et non un programme.

logical1
retrait_variables_statiques_locales(struct_processus *s_etat_processus)
{
	struct_liste_variables_statiques	*l_element_courant;
	struct_liste_variables_statiques	*l_element_suivant;

	unsigned char						registre_mode_execution;

	registre_mode_execution = (*s_etat_processus).mode_execution_programme;
	l_element_courant = (*s_etat_processus).l_liste_variables_statiques;

	while(l_element_courant != NULL)
	{
		l_element_suivant = (*l_element_courant).suivant;

		(*s_etat_processus).mode_execution_programme =
				((*(*l_element_courant).variable).origine == 'P') ? 'Y' : 'N';

		if ((*(*l_element_courant).variable).niveau > 0)
		{
			if (retrait_variable_statique(s_etat_processus,
					(*(*l_element_courant).variable).nom,
					(*(*l_element_courant).variable).variable_statique)
					== d_erreur)
			{
				(*s_etat_processus).mode_execution_programme =
						registre_mode_execution;
				return(d_erreur);
			}
		}

		l_element_courant = l_element_suivant;
	}

	(*s_etat_processus).mode_execution_programme = registre_mode_execution;
	return(d_absence_erreur);
}


/*
================================================================================
  Routine de création d'une nouvelle variable statique
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bords : néant
================================================================================
*/

logical1
creation_variable_statique(struct_processus *s_etat_processus,
		struct_variable_statique *s_variable)
{
	int										i;

	struct_arbre_variables					*l_variable_courante;

	struct_liste_variables_statiques		*l_nouvel_element;

	unsigned char							*ptr;

	// Ajout de la variable en tête de la liste des variables statiques

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

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

	(*(*l_nouvel_element).variable) = (*s_variable);

	(*l_nouvel_element).suivant = (*s_etat_processus)
			.l_liste_variables_statiques;
	(*l_nouvel_element).precedent = NULL;

	if ((*s_etat_processus).l_liste_variables_statiques != NULL)
	{
		(*(*s_etat_processus).l_liste_variables_statiques).precedent
				= l_nouvel_element;
	}

	(*s_etat_processus).l_liste_variables_statiques = l_nouvel_element;

	// Ajout de la variable à la feuille statique de l'arbre des variables

	if ((*s_etat_processus).s_arbre_variables == NULL)
	{
		if (((*s_etat_processus).s_arbre_variables =
					allocation_noeud(s_etat_processus)) == 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).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)
		{
			(*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_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,
				uprintf("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 et on le marque
			// comme utilisé dans la structure parente.

			if (((*l_variable_courante).noeuds[(*s_etat_processus)
					.pointeurs_caracteres_variables[*ptr]] =
					allocation_noeud(s_etat_processus)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(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_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
			// la structure parente et l'indice tableau_pere correspond à la
			// position réelle dans le tableau noeuds[] de la structure parente
			// du noeud courant. Cette valeur sera utilisée lors de la
			// destruction du noeud pour annuler le pointeur contenu dans
			// le tableau noeuds[] de la structure parente.

			(*(*l_variable_courante).noeuds[(*s_etat_processus)
			 		.pointeurs_caracteres_variables[*ptr]]).noeud_pere =
					l_variable_courante;
			(*(*l_variable_courante).noeuds[(*s_etat_processus)
			 		.pointeurs_caracteres_variables[*ptr]])
					.indice_tableau_pere = (*s_etat_processus)
					.pointeurs_caracteres_variables[*ptr];

			// Allocation du tableau noeuds[] et initialisation à zéro de
			// tous les pointeurs.

			if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
					.pointeurs_caracteres_variables[*ptr]]).noeuds =
					allocation_tableau_noeuds(s_etat_processus)) == 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_courante = (*l_variable_courante).noeuds
				[(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];
		ptr++;
	}

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

	// Dans la feuille statique de l'arbre des variables, on ne balaie
	// les variables que dans l'ordre. Le champ 'reference' est alors utilisé
	// pour sauvegarder une référence vers la liste des variables statiques
	// pour pouvoir purger l'élément en cas de besoin.

	(*l_nouvel_element).suivant = (*l_variable_courante).feuille_statique;
	(*l_nouvel_element).precedent = NULL;

	if ((*l_nouvel_element).suivant != NULL)
	{
		(*(*l_nouvel_element).suivant).precedent = l_nouvel_element;
	}

	(*l_nouvel_element).reference =
			(*s_etat_processus).l_liste_variables_statiques;
	(*l_nouvel_element).variable = (*(*s_etat_processus)
			.l_liste_variables_statiques).variable;
	(*l_variable_courante).feuille_statique = l_nouvel_element;
	(*l_nouvel_element).feuille = l_variable_courante;

	return(d_absence_erreur);
}


/*
================================================================================
  Procédure de retrait d'une variable statique de la base
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

logical1
retrait_variable_statique(struct_processus *s_etat_processus,
		unsigned char *nom_variable, union_position_variable position)
{
	struct_liste_variables_statiques		*l_element_a_supprimer;
	struct_liste_variables_statiques		*l_element_liste_a_supprimer;

	logical1								erreur;

	if ((l_element_a_supprimer = recherche_variable_statique(s_etat_processus,
			nom_variable, position, ((*s_etat_processus)
			.mode_execution_programme == 'Y') ? 'P' : 'E')) != NULL)
	{
		// (*s_etat_processus).pointeur_variable_statique_courante
		// pointe sur la variable à éliminer. Cette variable est celle qui
		// est présente dans l'une des feuilles statiques de l'arbre des
		// variables.

		l_element_liste_a_supprimer = (*l_element_a_supprimer).reference;

		// Suppression de la liste des variables statiques

		if ((*l_element_liste_a_supprimer).precedent != NULL)
		{
			// L'élément à supprimer n'est pas le premier de la liste.

			(*(*l_element_liste_a_supprimer).precedent).suivant =
					(*l_element_liste_a_supprimer).suivant;

			if ((*l_element_liste_a_supprimer).suivant != NULL)
			{
				// Il y a un élément suivant. On le chaîne.
				(*(*l_element_liste_a_supprimer).suivant).precedent	= NULL;
			}
		}
		else
		{
			// L'élement est le premier de la liste. S'il y a un élément
			// suivant, on le chaîne.

			if ((*l_element_liste_a_supprimer).suivant != NULL)
			{
				(*(*l_element_liste_a_supprimer).suivant).precedent = NULL;
			}

			(*s_etat_processus).l_liste_variables_statiques =
					(*l_element_liste_a_supprimer).suivant;
		}

		free(l_element_liste_a_supprimer);

		// Suppression depuis la feuille statique. Le champ 'precedent' ne sert
		// pas car la liste est simplement chaînée.

		if ((*l_element_a_supprimer).precedent != NULL)
		{
			// L'élément n'est pas le premier de la liste.

			(*(*l_element_a_supprimer).precedent).suivant =
					(*l_element_a_supprimer).suivant;

			if ((*l_element_a_supprimer).suivant != NULL)
			{
				(*(*l_element_a_supprimer).suivant).precedent =
						(*l_element_a_supprimer).precedent;
			}
			else
			{
				(*(*l_element_a_supprimer).precedent).suivant = NULL;
			}
		}
		else
		{
			// L'élément est le premier de la liste.

			if ((*l_element_a_supprimer).suivant != NULL)
			{
				(*(*l_element_a_supprimer).suivant).precedent = NULL;
			}

			(*(*l_element_a_supprimer).feuille).feuille_statique
					= (*l_element_a_supprimer).suivant;
		}

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

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

	return(erreur);
}


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

struct_liste_variables_statiques *
recherche_variable_statique(struct_processus *s_etat_processus,
		unsigned char *nom_variable, union_position_variable position,
		unsigned char origine)
{
	int									pointeur;

	struct_arbre_variables				*l_variable_courante;
	struct_liste_variables_statiques	*l_element_courant;

	unsigned char						*ptr;

	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

			(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
			return(NULL);
		}

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

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

	if ((*l_variable_courante).feuille_statique != NULL)
	{
		// Il existe au moins une variable statique du nom requis.

		l_element_courant = (*l_variable_courante).feuille_statique;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).variable).origine == 'P')
			{
				if (((*(*l_element_courant).variable).variable_statique.adresse
						== position.adresse) &&
						((*(*l_element_courant).variable).origine == origine))
				{
					(*s_etat_processus).pointeur_variable_statique_courante
							= (*l_element_courant).variable;
					return(l_element_courant);
				}
			}
			else
			{
				if (((*(*l_element_courant).variable).variable_statique.pointeur
						== position.pointeur) &&
						((*(*l_element_courant).variable).origine == origine))
				{
					(*s_etat_processus).pointeur_variable_statique_courante
							= (*l_element_courant).variable;
					return(l_element_courant);
				}
			}

			l_element_courant = (*l_element_courant).suivant;
		}
	}

	(*s_etat_processus).pointeur_variable_statique_courante = NULL;
	return(NULL);
}

// vim: ts=4