/*
================================================================================
  RPL/2 (R) version 4.0.19
  Copyright (C) 1989-2010 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 statique
================================================================================
  Entrée :
--------------------------------------------------------------------------------
  Sortie :
--------------------------------------------------------------------------------
  Effets de bords : néant
================================================================================
*/

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

	long								i;

	(*s_etat_processus).nombre_variables_statiques++;

	if ((*s_etat_processus).nombre_variables_statiques > (*s_etat_processus)
			.nombre_variables_statiques_allouees)
	{
		// La nouvelle variable statique ne tient pas dans la table courante.
		// Il convient donc d'en augmenter la taille.

		if ((*s_etat_processus).nombre_variables_statiques_allouees == 0)
		{
			(*s_etat_processus).nombre_variables_statiques_allouees =
					(*s_etat_processus).nombre_variables_statiques;
		}
		else
		{
			while((*s_etat_processus).nombre_variables_statiques >
					(*s_etat_processus).nombre_variables_statiques_allouees)
			{
				(*s_etat_processus).nombre_variables_statiques_allouees *= 2;
			}
		}

		if ((s_nouvelle_base = realloc((*s_etat_processus)
				.s_liste_variables_statiques, (*s_etat_processus)
				.nombre_variables_statiques_allouees *
				sizeof(struct_variable_statique))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			(*s_etat_processus).nombre_variables_statiques--;
			return(d_erreur);
		}

		(*s_etat_processus).s_liste_variables_statiques = s_nouvelle_base;
	}

	/*
	 * Positionnement de la variable statique au bon endroit
	 */

	// Nous avons (*s_etat_processus).nombre_variables_statiques - 1 variables
	// dans la table qui sera balayée de la fin vers le début.

	if ((*s_etat_processus).nombre_variables_statiques == 1)
	{
		(*s_etat_processus).s_liste_variables_statiques[0] = (*s_variable);
	}
	else
	{
		for(i = (*s_etat_processus).nombre_variables_statiques - 2; i >= 0; i--)
		{
			if (strcmp((*s_variable).nom,
					(*s_etat_processus).s_liste_variables_statiques[i].nom) < 0)
			{
				(*s_etat_processus).s_liste_variables_statiques[i + 1] =
						(*s_etat_processus).s_liste_variables_statiques[i];
			}
			else
			{
				break;
			}
		}

		(*s_etat_processus).s_liste_variables_statiques[i + 1] = (*s_variable);
	}

	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_variable_statique		*s_nouvelle_base;

	logical1						erreur;

	unsigned long					position_courante;
	unsigned long					position_supprimee;

	if (recherche_variable_statique(s_etat_processus, nom_variable,
			position, ((*s_etat_processus).mode_execution_programme == 'Y')
			? 'P' : 'E') == d_vrai)
	{
		if ((*s_etat_processus).nombre_variables_statiques <
				((*s_etat_processus).nombre_variables_statiques_allouees / 2))
		{
			(*s_etat_processus).nombre_variables_statiques_allouees /= 2;

			if ((s_nouvelle_base =
					realloc((*s_etat_processus).s_liste_variables_statiques,
					(*s_etat_processus).nombre_variables_statiques_allouees *
					sizeof(struct_variable_statique))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(d_erreur);
			}

			(*s_etat_processus).s_liste_variables_statiques = s_nouvelle_base;
		}

		position_supprimee = (*s_etat_processus)
				.position_variable_statique_courante;

		liberation(s_etat_processus, (*s_etat_processus)
				.s_liste_variables_statiques[position_supprimee].objet);
		free((*s_etat_processus).s_liste_variables_statiques
				[position_supprimee].nom);

		(*s_etat_processus).nombre_variables_statiques--;

		for(position_courante = position_supprimee; position_courante <
				(*s_etat_processus).nombre_variables_statiques;
				position_courante++)
		{
			(*s_etat_processus).s_liste_variables_statiques[position_courante]
					= (*s_etat_processus).s_liste_variables_statiques
					[position_courante + 1];
		}

		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
================================================================================
*/

logical1
recherche_variable_statique(struct_processus *s_etat_processus,
		unsigned char *nom_variable, union_position_variable position,
		unsigned char origine)
{
	logical1					existence_variable;

	long						difference;
	long						difference_inferieure;
	long						difference_superieure;

	unsigned long				borne_inferieure;
	unsigned long				borne_superieure;
	unsigned long				moyenne;
	unsigned long				nombre_iterations_maximal;
	unsigned long				ordre_iteration;

	if ((*s_etat_processus).nombre_variables_statiques == 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
		return d_faux;
	}

	ordre_iteration = 0;
	nombre_iterations_maximal = ((unsigned long)
			(log((*s_etat_processus).nombre_variables_statiques) / log(2))) + 2;

	borne_inferieure = 0;
	borne_superieure = (*s_etat_processus).nombre_variables_statiques - 1;

	do
	{
		moyenne = (borne_inferieure + borne_superieure) / 2;
		ordre_iteration++;

		if ((2 * ((unsigned long) ((borne_inferieure + borne_superieure) / 2)))
				== (borne_inferieure + borne_superieure))
		{
			difference = strcmp(nom_variable,
					((*s_etat_processus).s_liste_variables_statiques)
					[moyenne].nom);

			if (difference != 0)
			{
				if (difference > 0)
				{
					borne_inferieure = moyenne;
				}
				else
				{
					borne_superieure = moyenne;
				}
			}
		}
		else
		{
			difference_inferieure = strcmp(nom_variable,
					((*s_etat_processus).s_liste_variables_statiques)
					[moyenne].nom);
			difference_superieure = strcmp(nom_variable,
					((*s_etat_processus).s_liste_variables_statiques)
					[moyenne + 1].nom);

			if (difference_inferieure == 0)
			{
				difference = 0;
			}
			else if (difference_superieure == 0)
			{
				difference = 0;
				moyenne++;
			}
			else
			{
				difference = difference_inferieure;

				if (difference > 0)
				{
					borne_inferieure = moyenne;
				}
				else
				{
					borne_superieure = moyenne;
				}
			}
		}
	} while((difference != 0) &&
			(ordre_iteration <= nombre_iterations_maximal));

	if (ordre_iteration > nombre_iterations_maximal)
	{
		existence_variable = d_faux;
		(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
	}
	else
	{
		// Reste à rechercher la variable déclarée à la position 'position'...

		if (((*s_etat_processus).s_liste_variables_statiques)[moyenne]
				.origine == 'P')
		{
			if ((((*s_etat_processus).s_liste_variables_statiques)[moyenne]
					.variable_statique.adresse == position.adresse) &&
					(((*s_etat_processus).s_liste_variables_statiques)[moyenne]
					.origine == origine))
			{
				existence_variable = d_vrai;
			}
			else
			{
				existence_variable = d_faux;
			}
		}
		else
		{
			if ((((*s_etat_processus).s_liste_variables_statiques)[moyenne]
					.variable_statique.pointeur == position.pointeur) &&
					(((*s_etat_processus).s_liste_variables_statiques)[moyenne]
					.origine == origine))
			{
				existence_variable = d_vrai;
			}
			else
			{
				existence_variable = d_faux;
			}
		}

		if (existence_variable == d_faux)
		{
			// On rembobine.

			if (moyenne > 0)
			{
				while(strcmp(nom_variable, ((*s_etat_processus)
						.s_liste_variables_statiques)[moyenne - 1].nom) == 0)
				{
					moyenne--;

					if (moyenne == 0)
					{
						break;
					}
				}
			}

			// Un petit test pour voir si le premier élément du tableau
			// peut correspondre au critère de recherche.

			existence_variable = d_faux;

			if (strcmp(((*s_etat_processus).s_liste_variables_statiques)
					[moyenne].nom, nom_variable) == 0)
			{
				if (((*s_etat_processus).s_liste_variables_statiques)
						[moyenne].origine == 'P')
				{
					if ((((*s_etat_processus).s_liste_variables_statiques)
							[moyenne].variable_statique.adresse
							== position.adresse) &&
							(((*s_etat_processus).s_liste_variables_statiques)
							[moyenne].origine == origine))
					{
						existence_variable = d_vrai;
					}
				}
				else
				{
					if ((((*s_etat_processus).s_liste_variables_statiques)
							[moyenne].variable_statique.pointeur
							== position.pointeur) &&
							(((*s_etat_processus).s_liste_variables_statiques)
							[moyenne].origine == origine))
					{
						existence_variable = d_vrai;
					}
				}
			}

			// Puis on balaye dans le sens croissant.

			if (((moyenne + 1) < (*s_etat_processus)
					.nombre_variables_statiques) &&
					(existence_variable == d_faux))
			{
				while(strcmp(((*s_etat_processus)
						.s_liste_variables_statiques)[moyenne + 1].nom,
						nom_variable) == 0)
				{
					moyenne++;

					if (((*s_etat_processus).s_liste_variables_statiques)
							[moyenne].origine == 'P')
					{
						if ((((*s_etat_processus).s_liste_variables_statiques)
								[moyenne].variable_statique.adresse ==
								position.adresse) && (((*s_etat_processus)
								.s_liste_variables_statiques)
								[moyenne].origine == origine))
						{
							existence_variable = d_vrai;
							break;
						}
					}
					else
					{
						if ((((*s_etat_processus).s_liste_variables_statiques)
								[moyenne].variable_statique.pointeur ==
								position.pointeur) && (((*s_etat_processus)
								.s_liste_variables_statiques)
								[moyenne].origine == origine))
						{
							existence_variable = d_vrai;
							break;
						}
					}

					if ((moyenne + 1) >= (*s_etat_processus)
							.nombre_variables_statiques)
					{
						break;
					}
				}
			}
		}

		(*s_etat_processus).position_variable_statique_courante = moyenne;
	}

	return existence_variable;
}

// vim: ts=4