/*
================================================================================
  RPL/2 (R) version 4.1.21
  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"


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

void
instruction_var(struct_processus *s_etat_processus)
{
	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;
	struct_objet						*s_objet_temporaire;

	integer8							nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

		printf("->  1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);

		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, 0) == d_erreur)
		{
			return;
		}
	}

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;

		if ((*s_etat_processus).erreur_execution == d_ex)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		}

		return;
	}
	else
	{
		if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
				.type != MIN) && ((*(*(*s_etat_processus)
				.pointeur_variable_courante).objet).type != MRL))
		{
			(*s_etat_processus).erreur_execution =
					d_ex_matrice_statistique_invalide;
			return;
		}

		nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
				.pointeur_variable_courante).objet).objet))
				.nombre_colonnes;
	}

	s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
			.objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
				<= 1)
		{
			(*s_etat_processus).erreur_execution =
					d_ex_statistiques_echantillon;
			return;
		}

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

		if (((*s_objet_resultat).objet = variance_statistique(s_etat_processus,
				(struct_matrice *) (*s_objet_statistique).objet, 'E')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (nombre_colonnes == 1)
		{
			if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
			{
				(*s_objet_resultat).type = VIN;
				s_objet_temporaire = s_objet_resultat;

				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)) =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_temporaire).objet)).tableau)[0];

				liberation(s_etat_processus, s_objet_temporaire);
			}
			else
			{
				(*s_objet_resultat).type = VRL;
				s_objet_temporaire = s_objet_resultat;

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 *) (*((struct_vecteur *)
						(*s_objet_temporaire).objet)).tableau)[0];

				liberation(s_etat_processus, s_objet_temporaire);
			}
		}
		else
		{
			if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
			{
				(*s_objet_resultat).type = VIN;
			}
			else
			{
				(*s_objet_resultat).type = VRL;
			}
		}

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

	return;
}


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

void
instruction_version(struct_processus *s_etat_processus)
{
	int									nombre_champs;

	integer8							i1;
	integer8							i2;
	integer8							i3;
	integer8							i4;

	struct_liste_chainee				*l_element_courant;
	struct_liste_chainee				*l_element_interne_courant;

	struct_objet						*s_objet_resultat;

	unsigned char						texte[] = "RPL/2 version ";
	unsigned char						tampon[256 + 1];

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(version du séquenceur)\n\n");
		}
		else
		{
			printf("(sequencer version)\n\n");
		}

		printf("->  1: %s\n", 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, 0) == d_erreur)
		{
			return;
		}
	}

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

	if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*l_element_courant).donnee).objet = malloc((strlen(texte)
			+ strlen(d_version_rpl) + 1) * sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	sprintf((unsigned char *) (*(*l_element_courant).donnee).objet, "%s%s",
			texte, d_version_rpl);

	/*
	 * Ajout des versions X.Y.Z sous forme d'entiers
	 */

	i1 = 0;
	i2 = 0;
	i3 = 0;
	i4 = 0;

	nombre_champs = sscanf(d_version_rpl, "%lld.%lld.%lld.prerelease.%lld",
			&i1, &i2, &i3, &i4);

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*l_element_courant).donnee).objet =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_interne_courant = (struct_liste_chainee *)
			(*(*l_element_courant).donnee).objet;

	(*l_element_interne_courant).suivant = NULL;

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

	(*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i1;

	if (((*l_element_interne_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_interne_courant = (*l_element_interne_courant).suivant;
	(*l_element_interne_courant).suivant = NULL;

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

	(*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i2;

	if (((*l_element_interne_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_interne_courant = (*l_element_interne_courant).suivant;
	(*l_element_interne_courant).suivant = NULL;

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

	(*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i3;

	/*
	 * Ajout de "PRERELEASE" suivi d'un entier ou de "RELEASE"
	 */

	if (nombre_champs == 3)
	{
		// Version "RELEASE"

		if (((*l_element_interne_courant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_interne_courant = (*l_element_interne_courant).suivant;
		(*l_element_interne_courant).suivant = NULL;

		if (((*l_element_interne_courant).donnee =
				allocation(s_etat_processus, CHN)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*l_element_interne_courant).donnee).objet = malloc(8 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
				"RELEASE");
	}
	else
	{
		// Version "PRERELEASE"

		if (((*l_element_interne_courant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_interne_courant = (*l_element_interne_courant).suivant;
		(*l_element_interne_courant).suivant = NULL;

		if (((*l_element_interne_courant).donnee =
				allocation(s_etat_processus, CHN)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*l_element_interne_courant).donnee).objet = malloc(11 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
				"PRERELEASE");

		if (((*l_element_interne_courant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_interne_courant = (*l_element_interne_courant).suivant;
		(*l_element_interne_courant).suivant = NULL;

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

		(*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i4;
	}

	/*
	 * Ajout de la date de compilation
	 */

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*l_element_courant).donnee).objet =
			date_compilation(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	/*
	 * Ajout des options de compilation
	 */

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path)
			+ 1) * sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			d_exec_path);

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef GNUPLOT_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(8 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"GNUPLOT");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(17 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"GNUPLOT DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef FORCE_GNUPLOT_PATH
	if (((*(*l_element_courant).donnee).objet = malloc(19 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"FORCE GNUPLOT PATH");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(21 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"DEFAULT GNUPLOT PATH");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef POSTSCRIPT_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(11 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"POSTSCRIPT");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(20 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"POSTSCRIPT DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef VIM_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(4 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"VIM");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(13 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"VIM DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef MYSQL_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(6 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"MYSQL");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(15 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"MYSQL DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef POSTGRESQL_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(11 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"POSTGRESQL");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(20 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"POSTGRESQL DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef MOTIF_SUPPORT
	if (((*(*l_element_courant).donnee).objet = malloc(6 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"MOTIF");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(15 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"MOTIF DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef RPLCAS
	if (((*(*l_element_courant).donnee).objet = malloc(8 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"RPL/CAS");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(17 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"RPL/CAS DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

#ifdef EXPERIMENTAL_CODE
	if (((*(*l_element_courant).donnee).objet = malloc(18 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"EXPERIMENTAL CODE");
#else
	if (((*(*l_element_courant).donnee).objet = malloc(27 *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
			"EXPERIMENTAL CODE DISABLED");
#endif

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);

	if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
			* sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tampon);

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*l_element_courant).donnee).objet = conversion_majuscule(
			s_etat_processus, HOST)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	/*
	 * Empilement du résultat
	 */

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

	return;
}


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

void
instruction_vars(struct_processus *s_etat_processus)
{
	integer8							i;
	integer8							nb_variables;

	logical1							variable_partagee;

	struct_liste_chainee				*l_element_courant;
	struct_liste_chainee				*l_element_precedent;

	struct_objet						*s_objet_resultat;

	struct_tableau_variables			*tableau;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(liste des variables)\n\n");
		}
		else
		{
			printf("(list of variables)\n\n");
		}

		printf("->  1: %s\n", 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, 0) == d_erreur)
		{
			return;
		}
	}

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

	(*s_objet_resultat).objet = NULL;
	l_element_precedent = NULL;

	nb_variables = nombre_variables(s_etat_processus);

	if ((tableau = malloc(((size_t) nb_variables) *
			sizeof(struct_tableau_variables))) == NULL)
	{
		liberation_mutexes_arbre_variables_partagees(s_etat_processus,
				(*(*s_etat_processus).s_arbre_variables_partagees));
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	nb_variables = liste_variables(s_etat_processus, tableau);

	for(i = 0; i < nb_variables; i++)
	{
		if (l_element_precedent == NULL)
		{
			if (((*s_objet_resultat).objet =
					allocation_maillon(s_etat_processus)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_resultat).objet;
			(*l_element_courant).suivant = NULL;
		}
		else
		{
			if (((*l_element_precedent).suivant =
					allocation_maillon(s_etat_processus)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

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

		/*
		 * Allocation de la liste incluse
		 */

		if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		/*
		 * Mise en place d'un verrou si la variable est partagée.
		 */

		if (tableau[i].objet == NULL)
		{
			if (recherche_variable_partagee(s_etat_processus,
					tableau[i].nom, tableau[i].variable_partagee,
					tableau[i].origine) == NULL)
			{
				// La variable partagée n'existe plus.
				continue;
			}

			variable_partagee = d_vrai;
		}
		else
		{
			variable_partagee = d_faux;
		}

		/*
		 * Mise en place du nom de la variable
		 */

		if (((*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).donnee =
				allocation(s_etat_processus, NOM)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).donnee).objet))
				.symbole = d_vrai;

		if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).donnee).objet)).nom =
				malloc((strlen(tableau[i].nom)
				+ 1) * sizeof(unsigned char))) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
				(*((struct_objet *) (*l_element_courant).donnee)).objet))
				.donnee).objet)).nom, tableau[i].nom);

		/*
		 * Préparation du niveau
		 */

		if (((*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).donnee =
				allocation(s_etat_processus, INT)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
				(integer8) tableau[i].niveau;

		/*
		 * Préparation du contenu de la variable
		 */

		if (((*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (tableau[i].objet == NULL)
		{
			// Variable partagée

			if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.donnee = copie_objet(s_etat_processus,
					(*(*s_etat_processus).pointeur_variable_partagee_courante)
					.objet, 'P')) == NULL)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if (pthread_mutex_unlock(&((*(*s_etat_processus)
					.pointeur_variable_partagee_courante).mutex)) != 0)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else
		{
			// Variable privée

			if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.donnee = copie_objet(s_etat_processus, tableau[i].objet,
					'P')) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}

		/*
		 * Préparation du drapeau STATIC/VOLATILE
		 */

		if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant)
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
				.donnee = allocation(s_etat_processus, CHN)) == NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((tableau[i].origine == 'P')
				? (tableau[i].variable_statique.adresse != 0)
				: (tableau[i].variable_statique.pointeur != NULL))
		{
			if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).donnee).objet = malloc(7 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if (tableau[i].variable_masquee == d_vrai)
			{
				strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
						(*((struct_objet *) (*l_element_courant).donnee))
						.objet)).suivant).suivant).suivant).donnee).objet,
						"SHADOW");
			}
			else
			{
				strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
						(*((struct_objet *) (*l_element_courant).donnee))
						.objet)).suivant).suivant).suivant).donnee).objet,
						"STATIC");
			}
		}
		else
		{
			if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).donnee).objet = malloc(9 *
					sizeof(unsigned char))) == NULL)
			{ 
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant) .suivant).donnee).objet, "VOLATILE");
		}

		/*
		 * Préparation du drapeau LOCKED/UNLOCKED
		 */

		if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant)
				.suivant).suivant = allocation_maillon(s_etat_processus))
				== NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
				.suivant).donnee = allocation(s_etat_processus, CHN))
				== NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (tableau[i].variable_verrouillee == d_vrai)
		{
			if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).suivant).donnee).objet = malloc(7 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant).suivant).suivant).donnee).objet,
					"LOCKED");
		}
		else
		{
			if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).suivant).donnee).objet = malloc(9 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant).suivant).suivant).donnee).objet,
					"UNLOCKED");
		}

		/*
		 * Préparation du drapeau PRIVATE/SHARED/MAPPED
		 */

		if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant)
				.suivant).suivant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
				.suivant).suivant).donnee = allocation(s_etat_processus,
				CHN)) == NULL)
		{
			if (tableau[i].mutex != NULL)
			{
				// La variable est une variable partagée. On libère le mutex.
				pthread_mutex_unlock(tableau[i].mutex);
			}

			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (variable_partagee == d_vrai)
		{
			if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).suivant).suivant).donnee).objet = malloc(7 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant).suivant).suivant).suivant).donnee).objet,
					"MAPPED");
		}
		else if (tableau[i].mutex != NULL)
		{
			if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).suivant).suivant).donnee).objet = malloc(7 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant).suivant).suivant).suivant).donnee).objet,
					"SHARED");
		}
		else
		{
			if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
					(*l_element_courant).donnee)).objet)).suivant).suivant)
					.suivant).suivant).suivant).donnee).objet = malloc(8 *
					sizeof(unsigned char))) == NULL)
			{
				if (tableau[i].mutex != NULL)
				{
					// La variable est une variable partagée. On libère
					// le mutex.
					pthread_mutex_unlock(tableau[i].mutex);
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
					(*((struct_objet *) (*l_element_courant).donnee)).objet))
					.suivant).suivant).suivant).suivant).suivant).donnee).objet,
					"PRIVATE");
		}

		/*
		 * Fermeture de la liste incluse
		 */

		(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
				(*l_element_courant).donnee)).objet)).suivant).suivant)
		 		.suivant).suivant).suivant).suivant = NULL;

		l_element_precedent = l_element_courant;

		if (tableau[i].mutex != NULL)
		{
			// La variable est une variable partagée. On libère
			// le mutex.
			pthread_mutex_unlock(tableau[i].mutex);
		}
	}

	free(tableau);

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

	return;
}


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

void
instruction_visit(struct_processus *s_etat_processus)
{
	struct_liste_chainee				*registre_pile_last;

	struct_objet						*s_objet;

	integer8							profondeur_initiale;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(édition d'une variable)\n\n");
		}
		else
		{
			printf("(edit variable)\n\n");
		}

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

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

	registre_pile_last = NULL;

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

		registre_pile_last = (*s_etat_processus).l_base_pile_last;
		(*s_etat_processus).l_base_pile_last = NULL;
	}

	if ((*s_etat_processus).l_base_pile == NULL)
	{
		(*s_etat_processus).l_base_pile_last = registre_pile_last;
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
	{
		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;
		}

		liberation(s_etat_processus, s_objet);
		
		(*s_etat_processus).l_base_pile_last = registre_pile_last;
		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
	instruction_dup(s_etat_processus);

	if (((*s_etat_processus).erreur_systeme != d_es) ||
			((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep))
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}

		(*s_etat_processus).l_base_pile_last = registre_pile_last;

		return;
	}

	instruction_rcl(s_etat_processus);

	if (((*s_etat_processus).erreur_systeme != d_es) ||
			((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep))
	{
		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;
		}

		liberation(s_etat_processus, s_objet);

		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}

		(*s_etat_processus).l_base_pile_last = registre_pile_last;

		return;
	}

	instruction_edit(s_etat_processus);

	if (((*s_etat_processus).erreur_systeme != d_es) ||
			((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep))
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}

		(*s_etat_processus).l_base_pile_last = registre_pile_last;

		return;
	}

	while(profondeur_initiale != ((*s_etat_processus)
			.hauteur_pile_operationnelle - 1))
	{
		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;
		}

		liberation(s_etat_processus, s_objet);
	}

	instruction_swap(s_etat_processus);

	if (((*s_etat_processus).erreur_systeme != d_es) ||
			((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep))
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}

		(*s_etat_processus).l_base_pile_last = registre_pile_last;

		return;
	}

	instruction_sto(s_etat_processus);

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

		(*s_etat_processus).l_base_pile_last = registre_pile_last;
	}

	return;
}


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

void
instruction_variable(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  VARIABLE ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(déverrouille une variable globale)\n\n");
		}
		else
		{
			printf("(unlock a global 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_globale(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;
		}

		(*(*s_etat_processus).pointeur_variable_courante)
				.variable_verrouillee = d_faux;
	}
	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_globale(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;
			}

			(*(*s_etat_processus).pointeur_variable_courante)
					.variable_verrouillee = d_faux;

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

// vim: ts=4