/*
================================================================================
  RPL/2 (R) version 4.1.7
  Copyright (C) 1989-2012 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"


/*
================================================================================
  Fonction 'volatile'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_volatile(struct_processus *s_etat_processus)
{
	struct_liste_chainee				*l_element_courant;

	struct_objet						*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  VOLATILE ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(rend volatile une variable statique)\n\n");
		}
		else
		{
			printf("(make volatile a static variable)\n\n");
		}

		printf("    1: %s, %s\n", d_NOM, d_LST);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}
	
	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*s_objet).type == NOM)
	{
		if (recherche_variable(s_etat_processus, ((*((struct_nom *)
				(*s_objet).objet)).nom)) == d_faux)
		{
			liberation(s_etat_processus, s_objet);

			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
			return;
		}

		if (((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
				? ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_statique.adresse == 0)
				: ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_statique.pointeur == NULL))
		{
			liberation(s_etat_processus, s_objet);

			(*s_etat_processus).erreur_execution = d_ex_variable_volatile;
			return;
		}
		else
		{
			if (retrait_variable_statique(s_etat_processus,
					(*((struct_nom *) (*s_objet).objet)).nom,
					(*(*s_etat_processus).pointeur_variable_courante)
					.variable_statique) == d_erreur)
			{
				liberation(s_etat_processus, s_objet);
				return;
			}

			if ((*(*s_etat_processus).pointeur_variable_courante).origine
					== 'P')
			{
				(*(*s_etat_processus).pointeur_variable_courante)
						.variable_statique.adresse = 0;
			}
			else
			{
				(*(*s_etat_processus).pointeur_variable_courante)
						.variable_statique.pointeur = NULL;
			}
		}
	}
	else if ((*s_objet).type == LST)
	{
		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != NOM)
			{
				liberation(s_etat_processus, s_objet);

				(*s_etat_processus).erreur_execution = d_ex_nom_invalide;
				return;
			}

			if (recherche_variable(s_etat_processus, (*((struct_nom *)
					(*(*l_element_courant).donnee).objet)).nom) == d_faux)
			{
				liberation(s_etat_processus, s_objet);

				(*s_etat_processus).erreur_systeme = d_es;
				(*s_etat_processus).erreur_execution =
						d_ex_variable_non_definie;
				return;
			}

			if (((*(*s_etat_processus).pointeur_variable_courante)
					.origine == 'P') ? ((*(*s_etat_processus)
					.pointeur_variable_courante).variable_statique.adresse == 0)
					: ((*(*s_etat_processus).pointeur_variable_courante)
					.variable_statique.pointeur == NULL))
			{
				liberation(s_etat_processus, s_objet);

				(*s_etat_processus).erreur_execution = d_ex_variable_volatile;
				return;
			}
			else
			{
				if (retrait_variable_statique(s_etat_processus,
						(*((struct_nom *) (*s_objet).objet)).nom,
						(*(*s_etat_processus).pointeur_variable_courante)
						.variable_statique) == d_erreur)
				{
					liberation(s_etat_processus, s_objet);
					return;
				}

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

			l_element_courant = (*l_element_courant).suivant;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet);

	return;
}


/*
================================================================================
  Fonction 'verify'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_verify(struct_processus *s_etat_processus)
{
	int								position;

	integer8						i1;
	integer8						i2;
	integer8						i3;
	integer8						i4;
	integer8						j1;
	integer8						j2;
	integer8						j3;
	integer8						j4;

	logical1						drapeau;
	logical1						drapeau_final;
	logical1						drapeau_final_courant;
	logical1						drapeau_prerelease;
	logical1						drapeau_prerelease_courant;
	logical1						last_valide;

	struct_liste_chainee			*l_element_caracteristiques;
	struct_liste_chainee			*l_element_courant;
	struct_liste_chainee			*l_element_version;

	struct_objet					*s_objet_argument;
	struct_objet					*s_objet_caracteristiques;
	struct_objet					*s_objet_resultat;

	unsigned char					*chaine_majuscule;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  VERIFY ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(vérification des caractéristiques du langage)\n\n");
		}
		else
		{
			printf("(checks of the language characteristics)\n\n");
		}

		printf("    1: %s\n", d_LST);
		printf("->  1: %s (0 or -1)\n\n", d_INT);

		if ((*s_etat_processus).langue == 'F')
		{
			printf("  Utilisation :\n\n");
		}
		else
		{
			printf("  Usage:\n\n");
		}

		printf("    { { 4 0 0 \"PRERELEASE\" 4 } \"POSTGRESQL\" } VERIFY\n");
		printf("    { { 4 0 0 } } VERIFY\n");

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*s_objet_argument).type == LST)
	{
		if (last_valide == d_vrai)
		{
			cf(s_etat_processus, 31);
		}

		instruction_version(s_etat_processus);

		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				&s_objet_caracteristiques) == d_erreur)
		{
			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
			return;
		}

		/*
		 * L'objet renvoyé est obligatoirement une liste.
		 */

		BUG((*s_objet_caracteristiques).type != LST,
				printf("(*s_objet_caracteristiques).type='%d'\n",
				(*s_objet_caracteristiques).type));

		drapeau = d_vrai;
		l_element_courant = (*s_objet_argument).objet;

		while((l_element_courant != NULL) && (drapeau == d_vrai))
		{
			if ((*(*l_element_courant).donnee).type == CHN)
			{
				if ((chaine_majuscule = conversion_majuscule((unsigned char *)
						(*(*l_element_courant).donnee).objet)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_caracteristiques = (*s_objet_caracteristiques).objet;

				while(l_element_caracteristiques != NULL)
				{
					if ((*(*l_element_caracteristiques).donnee).type == CHN)
					{
						if (strcmp((unsigned char *)
								(*(*l_element_caracteristiques).donnee).objet,
								chaine_majuscule) == 0)
						{
							break;
						}
					}

					l_element_caracteristiques = (*l_element_caracteristiques)
							.suivant;
				}

				free(chaine_majuscule);

				if (l_element_caracteristiques == NULL)
				{ // La chaîne n'a pas été trouvée...
					drapeau = d_faux;
					break;
				}
			}
			else if ((*(*l_element_courant).donnee).type == LST)
			{
				drapeau_final = d_vrai;
				drapeau_prerelease = d_faux;
				drapeau_final_courant = d_vrai;
				drapeau_prerelease_courant = d_faux;
				i1 = 0;
				i2 = 0;
				i3 = 0;
				i4 = 0;
				j1 = 0;
				j2 = 0;
				j3 = 0;
				j4 = 0;

				l_element_version = (*(*l_element_courant).donnee).objet;
				position = 1;

				while(l_element_version != NULL)
				{
					switch(position)
					{
						case 1 :
						{
							if ((*(*l_element_version).donnee).type == INT)
							{
								i1 = (*((integer8 *) (*(*l_element_version)
										.donnee).objet));
							}
							else
							{
								liberation(s_etat_processus, s_objet_argument);
								liberation(s_etat_processus,
										s_objet_caracteristiques);

								(*s_etat_processus).erreur_execution =
										d_ex_erreur_type_argument;
								return;
							}

							break;
						}

						case 2 :
						{
							if ((*(*l_element_version).donnee).type == INT)
							{
								i2 = (*((integer8 *) (*(*l_element_version)
										.donnee).objet));
							}
							else
							{
								liberation(s_etat_processus, s_objet_argument);
								liberation(s_etat_processus,
										s_objet_caracteristiques);

								(*s_etat_processus).erreur_execution =
										d_ex_erreur_type_argument;
								return;
							}

							break;
						}

						case 3 :
						{
							if ((*(*l_element_version).donnee).type == INT)
							{
								i3 = (*((integer8 *) (*(*l_element_version)
										.donnee).objet));
							}
							else
							{
								liberation(s_etat_processus, s_objet_argument);
								liberation(s_etat_processus,
										s_objet_caracteristiques);

								(*s_etat_processus).erreur_execution =
										d_ex_erreur_type_argument;
								return;
							}

							break;
						}

						case 4 :
						{
							if ((*(*l_element_version).donnee).type == CHN)
							{
								if ((chaine_majuscule = conversion_majuscule(
										(unsigned char *) (*(*l_element_version)
										.donnee).objet)) == NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return;
								}

								if (strcmp(chaine_majuscule, "RELEASE") == 0)
								{
									drapeau_final = d_vrai;
								}
								else if (strcmp(chaine_majuscule, "PRERELEASE")
										== 0)
								{
									drapeau_final = d_faux;
								}
								else
								{
									liberation(s_etat_processus,
											s_objet_argument);
									liberation(s_etat_processus,
											s_objet_caracteristiques);

									(*s_etat_processus).erreur_execution =
											d_ex_argument_invalide;
									return;
								}

								free(chaine_majuscule);
							}
							else
							{
								liberation(s_etat_processus, s_objet_argument);
								liberation(s_etat_processus,
										s_objet_caracteristiques);

								(*s_etat_processus).erreur_execution =
										d_ex_erreur_type_argument;
								return;
							}

							break;
						}

						case 5 :
						{
							if ((*(*l_element_version).donnee).type == INT)
							{
								i4 = (*((integer8 *) (*(*l_element_version)
										.donnee).objet));
							}
							else
							{
								liberation(s_etat_processus, s_objet_argument);
								liberation(s_etat_processus,
										s_objet_caracteristiques);

								(*s_etat_processus).erreur_execution =
										d_ex_erreur_type_argument;
								return;
							}

							drapeau_prerelease = d_vrai;
							break;
						}

						default :
						{
							liberation(s_etat_processus, s_objet_argument);
							liberation(s_etat_processus,
									s_objet_caracteristiques);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_type_argument;
							return;
							break;
						}
					}

					position++;
					l_element_version = (*l_element_version).suivant;
				}

				if (drapeau_prerelease == drapeau_final)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_caracteristiques);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}

				l_element_caracteristiques = (*s_objet_caracteristiques).objet;

				while(l_element_caracteristiques != NULL)
				{
					if ((*(*l_element_caracteristiques).donnee).type == LST)
					{
						l_element_version = (*(*l_element_caracteristiques)
								.donnee).objet;

						position = 1;

						while(l_element_version != NULL)
						{
							switch(position)
							{
								case 1 :
								{
									j1 = (*((integer8 *) (*(*l_element_version)
											.donnee).objet));
									break;
								}

								case 2 :
								{
									j2 = (*((integer8 *) (*(*l_element_version)
											.donnee).objet));
									break;
								}

								case 3 :
								{
									j3 = (*((integer8 *) (*(*l_element_version)
											.donnee).objet));
									break;
								}

								case 4 :
								{
									drapeau_final_courant =
											(strcmp((unsigned char *)
											(*(*l_element_version).donnee)
											.objet, "RELEASE") == 0)
											? d_vrai : d_faux;
									break;
								}

								case 5 :
								{
									j4 = (*((integer8 *) (*(*l_element_version)
											.donnee).objet));
									drapeau_prerelease_courant = d_vrai;
									break;
								}
							}

							position++;
							l_element_version = (*l_element_version).suivant;
						}

						break;
					}

					l_element_caracteristiques = (*l_element_caracteristiques)
							.suivant;
				}

				if (drapeau_prerelease_courant == drapeau_final_courant)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_caracteristiques);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}

				if (i1 > j1)
				{ // Version demandée supérieure à la version courante
					drapeau = d_faux;
				}
				else if (i1 == j1)
				{
					if (i2 > j2)
					{ // Versions idendiques et sous-version demandée
					  // supérieure à la sous-version courante
						drapeau = d_faux;
					}
					else if (i2 == j2)
					{ // Versions et sous-versions identiques
						if (i3 > j3)
						{ // Niveau de patches demandé supérieur au niveau
						  // de patch courant
							drapeau = d_faux;
						}
						else if (i3 == j3)
						{ // Niveaux de patches indentiques
							if ((drapeau_final == d_vrai) &&
									(drapeau_final_courant == d_faux))
							{ // Finale requise et prerelease obtenue
								drapeau = d_faux;
							}
							else if ((drapeau_final == d_faux) &&
									(drapeau_final_courant == d_vrai))
							{ // Prerelease requise et finale obtenue
							}
							else if ((drapeau_final == d_vrai) &&
									(drapeau_final_courant == d_vrai))
							{ // Finales de part et d'autre
							}
							else
							{ // Prerelease de part et d'autre
								if (i4 > j4)
								{ // Prerelease demandée supérieur à la
								  // version courante
									drapeau = d_faux;
								}
							}
						}
						else
						{ // Niveaux de patches inférieur au niveau courant
						}
					}
					else
					{ // Versions indentiques et sous-version inférieure à
					  // la sous-version courante
					}
				}
				else
				{ // Version demandée inférieure à la version courante
				}
			}
			else
			{
				liberation(s_etat_processus, s_objet_argument);
				liberation(s_etat_processus, s_objet_caracteristiques);

				(*s_etat_processus).erreur_execution =
						d_ex_erreur_type_argument;
				return;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		liberation(s_etat_processus, s_objet_caracteristiques);

		/*
		 * Création du drapeau renvoyé
		 */

		if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((integer8 *) (*s_objet_resultat).objet)) = (drapeau == d_vrai)
				? -1 : 0;

		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_resultat) == d_erreur)
		{
			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument);

	return;
}

// vim: ts=4