/*
================================================================================
  RPL/2 (R) version 4.1.29
  Copyright (C) 1989-2018 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 'get'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

static int
fonction_comparaison(const void *argument_1, const void *argument_2)
{
	/*
	uprintf("%p->%s\n",(unsigned char *) (**((struct_objet **) argument_2)).objet, (unsigned char *) (**((struct_objet **) argument_2)).objet);
	uprintf("%p->%s\n",(unsigned char *) (**((struct_objet **) argument_1)).objet, (unsigned char *) (**((struct_objet **) argument_1)).objet);
	*/
	return(strcmp((unsigned char *) (**((struct_objet **) argument_1)).objet,
			(unsigned char *) (**((struct_objet **) argument_2)).objet));
}


void
instruction_get(struct_processus *s_etat_processus)
{
	logical1							variable_partagee;

	struct_liste_chainee				*l_element_courant;

	struct_objet						*s_objet_1;
	struct_objet						*s_objet_2;
	struct_objet						*s_objet_3;
	struct_objet						*s_objet_element;
	struct_objet						*s_objet_noms;
	struct_objet						*s_objet_resultat;

	integer8							indice_i;
	integer8							indice_j;
	integer8							nombre_dimensions;

	unsigned char						*registre_instruction_courante;
	unsigned char						registre_instruction_valide;
	unsigned char						registre_test;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(prend un élément)\n\n");
		}
		else
		{
			printf("(get element)\n\n");
		}

		printf("    2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
		printf("    1: %s\n", d_LST);
		printf("->  1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);

		printf("    2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
		printf("    1: %s\n", d_LST);
		printf("->  1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);

		printf("    2: %s, %s\n", d_TAB, d_NOM);
		printf("    1: %s\n", d_LST);
		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

		printf("    2: %s\n", d_REC);
		printf("    1: %s\n", d_CHN);
		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

		printf("    2: %s, %s\n", d_LST, d_NOM);
		printf("    1: %s\n", d_INT);
		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

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

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_1);

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

/*
--------------------------------------------------------------------------------
  Traitement des éléments des vecteurs
--------------------------------------------------------------------------------
*/

	if (((*s_objet_2).type == VIN) ||
			((*s_objet_2).type == VRL) ||
			((*s_objet_2).type == VCX))
	{
		if ((*s_objet_1).type != LST)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;
		nombre_dimensions = 0;

		while(l_element_courant != NULL)
		{
			nombre_dimensions++;
			l_element_courant = (*l_element_courant).suivant;
		}

		if (nombre_dimensions != 1)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;

		if ((*(*l_element_courant).donnee).type != INT)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return;
		}
		else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
				(integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

		if ((*s_objet_2).type == VIN)
		{
			/*
			 * Vecteur d'entiers
			 */

			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_2).objet))
					.tableau)[indice_i - 1];
		}
		else if ((*s_objet_2).type == VRL)
		{
			/*
			 * Vecteur de réels
			 */

			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_2).objet))
					.tableau)[indice_i - 1];
		}
		else
		{
			/*
			 * Vecteur de complexes
			 */

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

			(*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
					((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle;
			(*((struct_complexe16 *) (*s_objet_resultat).objet))
					.partie_imaginaire = ((struct_complexe16 *)
					(*((struct_vecteur *) (*s_objet_2).objet)).tableau)
					[indice_i - 1].partie_imaginaire;
		}
	}

/*
--------------------------------------------------------------------------------
  Traitement des éléments des matrices
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_2).type == MIN) ||
			((*s_objet_2).type == MRL) ||
			((*s_objet_2).type == MCX))
	{
		if ((*s_objet_1).type != LST)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;
		nombre_dimensions = 0;

		while(l_element_courant != NULL)
		{
			nombre_dimensions++;
			l_element_courant = (*l_element_courant).suivant;
		}

		if (nombre_dimensions != 2)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;

		indice_i = 0;
		indice_j = 0;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if (indice_i == 0)
			{
				indice_i = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}
			else
			{
				indice_j = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet))
				.nombre_lignes) || (indice_j > (*((struct_matrice *)
				(*s_objet_2).objet)).nombre_colonnes))
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		if ((*s_objet_2).type == MIN)
		{
			/*
			 * Matrice d'entiers
			 */

			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_matrice *) (*s_objet_2).objet))
					.tableau)[indice_i - 1][indice_j - 1];
		}
		else if ((*s_objet_2).type == MRL)
		{
			/*
			 * Matrice de réels
			 */

			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_matrice *) (*s_objet_2).objet))
					.tableau)[indice_i - 1][indice_j - 1];
		}
		else
		{
			/*
			 * Matrices de complexes
			 */

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

			(*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
					((struct_complexe16 **) (*((struct_matrice *)
					(*s_objet_2).objet)).tableau)[indice_i - 1]
					[indice_j - 1].partie_reelle;
			(*((struct_complexe16 *) (*s_objet_resultat).objet))
					.partie_imaginaire = ((struct_complexe16 **)
					(*((struct_matrice *) (*s_objet_2).objet)).tableau)
					[indice_i - 1][indice_j - 1].partie_imaginaire;
		}
	}

/*
--------------------------------------------------------------------------------
  Traitement des listes
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == LST)
	{
		if ((*s_objet_1).type != INT)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		indice_i = (*((integer8 *) (*s_objet_1).objet));
		indice_j = 1;

		l_element_courant = (*s_objet_2).objet;

		while((l_element_courant != NULL) && (indice_j != indice_i))
		{
			l_element_courant = (*l_element_courant).suivant;
			indice_j++;
		}

		if (l_element_courant != NULL)
		{
			if ((s_objet_resultat = copie_objet(s_etat_processus,
					(*l_element_courant).donnee, 'P')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}
		else
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

/*
--------------------------------------------------------------------------------
  Traitement des tables
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == TBL)
	{
		if ((*s_objet_1).type != LST)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;
		s_objet_element = s_objet_2;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*s_objet_element).type != TBL)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
					(*s_objet_element).objet)).nombre_elements))
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			s_objet_element = (*((struct_tableau *) (*s_objet_element)
					.objet)).elements[indice_i - 1];
			l_element_courant = (*l_element_courant).suivant;
		}

		if ((s_objet_resultat = copie_objet(s_etat_processus,
				s_objet_element, 'P')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Traitement des enregistrements
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == REC)
	{
		if ((*s_objet_1).type != CHN)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		s_objet_noms = (*((struct_record *) (*s_objet_2).objet)).noms;

		int i;
		for(i = 0; i < (*((struct_tableau *) (*s_objet_noms).objet)).nombre_elements; uprintf("%d->%p (%s)\n", i,
	(unsigned char *) (*(*((struct_tableau *) (*s_objet_noms).objet)).elements[i]).objet,
	(unsigned char *) (*(*((struct_tableau *) (*s_objet_noms).objet)).elements[i]).objet), i++);

		s_objet_element = bsearch((unsigned char *) (*s_objet_1).objet,
				(*((struct_tableau *) (*s_objet_noms).objet)).elements,
				(size_t) (*((struct_tableau *) (*s_objet_noms).objet))
				.nombre_elements, sizeof(struct_objet *), fonction_comparaison);

		uprintf("%d\n", s_objet_element - (*((struct_tableau *) (*s_objet_2).objet)).elements[0]);

		/*
		l_element_courant = (*s_objet_1).objet;
		s_objet_element = s_objet_2;


		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*s_objet_element).type != TBL)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
					(*s_objet_element).objet)).nombre_elements))
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			s_objet_element = (*((struct_tableau *) (*s_objet_element)
					.objet)).elements[indice_i - 1];
			l_element_courant = (*l_element_courant).suivant;
		}
		if ((s_objet_resultat = copie_objet(s_etat_processus,
				s_objet_element, 'P')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
		*/
	}
/*
--------------------------------------------------------------------------------
  Traitement des variables
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == NOM)
	{
		variable_partagee = d_faux;

		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_2).objet)).nom) == d_faux)
		{
			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;

			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

			return;
		}

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

		if (s_objet_3 == NULL)
		{
			if (recherche_variable_partagee(s_etat_processus,
					(*(*s_etat_processus).pointeur_variable_courante).nom,
					(*(*s_etat_processus).pointeur_variable_courante)
					.variable_partagee, (*(*s_etat_processus)
					.pointeur_variable_courante).origine) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es;
				(*s_etat_processus).erreur_execution =
						d_ex_variable_non_definie;

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

				return;
			}

			s_objet_3 = (*(*s_etat_processus)
					.pointeur_variable_partagee_courante).objet;
			variable_partagee = d_vrai;
		}

		if (((*s_objet_3).type == VIN) ||
				((*s_objet_3).type == VRL) ||
				((*s_objet_3).type == VCX))
		{
			if ((*s_objet_1).type != LST)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;
			nombre_dimensions = 0;

			while(l_element_courant != NULL)
			{
				nombre_dimensions++;
				l_element_courant = (*l_element_courant).suivant;
			}

			if (nombre_dimensions != 1)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;

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

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

				(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
				return;
			}
			else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
					(integer8) (*((struct_vecteur *) (*s_objet_3).objet))
					.taille)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((*s_objet_3).type == VIN)
			{
				/*
				 * Vecteur d'entiers
				 */

				if ((s_objet_resultat = 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;
						}
					}

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

				(*((integer8 *) (*s_objet_resultat).objet)) =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_3).objet)).tableau)[indice_i - 1];
			}
			else if ((*s_objet_3).type == VRL)
			{
				/*
				 * Vecteur de réels
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, REL))
						== 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;
						}
					}

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
						.tableau)[indice_i - 1];
			}
			else
			{
				/*
				 * Vecteur de complexes
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, CPL))
						== 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;
						}
					}

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

				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_reelle = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_3).objet))
						.tableau)[indice_i - 1].partie_reelle;
				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_imaginaire = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_3).objet)).tableau)
						[indice_i - 1].partie_imaginaire;
			}
		}
		else if (((*s_objet_3).type == MIN) ||
				((*s_objet_3).type == MRL) ||
				((*s_objet_3).type == MCX))
		{
			if ((*s_objet_1).type != LST)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;
			nombre_dimensions = 0;

			while(l_element_courant != NULL)
			{
				nombre_dimensions++;
				l_element_courant = (*l_element_courant).suivant;
			}

			if (nombre_dimensions != 2)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;

			indice_i = 0;
			indice_j = 0;

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type != INT)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				if ((*((integer8 *) (*(*l_element_courant)
						.donnee).objet)) <= 0)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				if (indice_i == 0)
				{
					indice_i = (*((integer8 *)
							(*(*l_element_courant).donnee).objet));
				}
				else
				{
					indice_j = (*((integer8 *)
							(*(*l_element_courant).donnee).objet));
				}

				l_element_courant = (*l_element_courant).suivant;
			}

			if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
					.nombre_lignes) || (indice_j > (*((struct_matrice *)
					(*s_objet_3).objet)).nombre_colonnes))
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*s_objet_3).type == MIN)
			{
				/*
				 * Matrice d'entiers
				 */

				if ((s_objet_resultat = 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;
						}
					}

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

				(*((integer8 *) (*s_objet_resultat).objet)) =
						((integer8 **) (*((struct_matrice *)
						(*s_objet_3).objet))
						.tableau)[indice_i - 1][indice_j - 1];
			}
			else if ((*s_objet_3).type == MRL)
			{
				/*
				 * Matrice de réels
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, REL))
						== 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;
						}
					}

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
						.tableau)[indice_i - 1][indice_j - 1];
			}
			else
			{
				/*
				 * Matrices de complexes
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, CPL))
						== 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;
						}
					}

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

				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_reelle = ((struct_complexe16 **)
						(*((struct_matrice *)
						(*s_objet_3).objet)).tableau)[indice_i - 1]
						[indice_j - 1].partie_reelle;
				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_imaginaire = ((struct_complexe16 **)
						(*((struct_matrice *) (*s_objet_3).objet)).tableau)
						[indice_i - 1][indice_j - 1].partie_imaginaire;
			}
		}
		else if ((*s_objet_3).type == LST)
		{
			if ((*s_objet_1).type != INT)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			indice_i = (*((integer8 *) (*s_objet_1).objet));
			indice_j = 1;

			l_element_courant = (*s_objet_3).objet;

			while((l_element_courant != NULL) && (indice_j != indice_i))
			{
				l_element_courant = (*l_element_courant).suivant;
				indice_j++;
			}

			if (l_element_courant != NULL)
			{
				if ((s_objet_resultat = copie_objet(s_etat_processus,
						(*l_element_courant).donnee, 'P')) == 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;
						}
					}

					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}
			}
			else
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

				(*s_etat_processus).erreur_execution = d_ex_element_inexistant;
				return;
			}
		}
		else if ((*s_objet_3).type == TBL)
		{
			if ((*s_objet_1).type != LST)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;
			s_objet_element = s_objet_3;

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type != INT)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				if ((*s_objet_element).type != TBL)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				indice_i = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
						(*s_objet_element).objet)).nombre_elements))
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				s_objet_element = (*((struct_tableau *) (*s_objet_element)
						.objet)).elements[indice_i - 1];
				l_element_courant = (*l_element_courant).suivant;
			}

			if ((s_objet_resultat = copie_objet(s_etat_processus,
					s_objet_element, 'P')) == 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;
					}
				}

				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}
		else
		{
			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;
				}
			}

			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

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

/*
--------------------------------------------------------------------------------
  Type incompatible avec la fonction GET
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_1);
		liberation(s_etat_processus, s_objet_2);

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

	liberation(s_etat_processus, s_objet_1);
	liberation(s_etat_processus, s_objet_2);

	if ((*s_objet_resultat).type == NOM)
	{
		if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
		{
			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
			{
				return;
			}
		}
		else
		{
			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_resultat) == d_erreur)
			{
				return;
			}
		}
	}
	else if ((*s_objet_resultat).type == FCT)
	{
		registre_test = (*s_etat_processus).test_instruction;
		registre_instruction_courante = (*s_etat_processus)
				.instruction_courante;
		registre_instruction_valide = (*s_etat_processus)
				.instruction_valide;

		(*s_etat_processus).test_instruction = 'Y';
		(*s_etat_processus).instruction_courante =
				(*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;

		analyse(s_etat_processus, NULL);

		(*s_etat_processus).test_instruction = registre_test;
		(*s_etat_processus).instruction_courante =
				registre_instruction_courante;

		if (((*s_etat_processus).instruction_valide == 'Y') &&
				(*s_etat_processus).constante_symbolique == 'Y')
		{
			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
			{
				(*s_etat_processus).instruction_valide =
						registre_instruction_valide;
				return;
			}
		}
		else
		{
			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_resultat) == d_erreur)
			{
				(*s_etat_processus).instruction_valide =
						registre_instruction_valide;
				return;
			}
		}

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

	return;
}


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

void
instruction_geti(struct_processus *s_etat_processus)
{
	logical1							variable_partagee;

	struct_liste_chainee				*l_element_courant;

	struct_objet						*s_copie_1;
	struct_objet						*s_objet_1;
	struct_objet						*s_objet_2;
	struct_objet						*s_objet_3;
	struct_objet						*s_objet_resultat;

	integer8							indice_i;
	integer8							indice_j;
	integer8							nombre_dimensions;
	integer8							nombre_elements;

	unsigned char						*registre_instruction_courante;
	unsigned char						registre_instruction_valide;
	unsigned char						registre_test;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(prend un élément)\n\n");
		}
		else
		{
			printf("(get element)\n\n");
		}

		printf("    2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
		printf("    1: %s\n", d_LST);
		printf("->  3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
		printf("    2: %s\n", d_LST);
		printf("    1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);

		printf("    2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
		printf("    1: %s\n", d_LST);
		printf("->  3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
		printf("    2: %s\n", d_LST);
		printf("    1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);

		printf("    2: %s, %s\n", d_LST, d_NOM);
		printf("    1: %s\n", d_INT);
		printf("->  3: %s, %s\n", d_LST, d_NOM);
		printf("    2: %s\n", d_INT);
		printf("    1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

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

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_1);

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

	if ((s_copie_1 = copie_objet(s_etat_processus, s_objet_1, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	liberation(s_etat_processus, s_objet_1);
	s_objet_1 = s_copie_1;

/*
--------------------------------------------------------------------------------
  Traitement des éléments des vecteurs
--------------------------------------------------------------------------------
*/

	if (((*s_objet_2).type == VIN) ||
			((*s_objet_2).type == VRL) ||
			((*s_objet_2).type == VCX))
	{
		if ((*s_objet_1).type != LST)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;
		nombre_dimensions = 0;

		while(l_element_courant != NULL)
		{
			nombre_dimensions++;
			l_element_courant = (*l_element_courant).suivant;
		}

		if (nombre_dimensions != 1)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;

		if ((*(*l_element_courant).donnee).type != INT)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return;
		}
		else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
				(integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

		if ((*s_objet_2).type == VIN)
		{
			/*
			 * Vecteur d'entiers
			 */

			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_2).objet))
					.tableau)[indice_i - 1];
		}
		else if ((*s_objet_2).type == VRL)
		{
			/*
			 * Vecteur de réels
			 */

			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_2).objet))
					.tableau)[indice_i - 1];
		}
		else
		{
			/*
			 * Vecteur de complexes
			 */

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

			(*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
					((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle;
			(*((struct_complexe16 *) (*s_objet_resultat).objet))
					.partie_imaginaire = ((struct_complexe16 *)
					(*((struct_vecteur *) (*s_objet_2).objet)).tableau)
					[indice_i - 1].partie_imaginaire;
		}

		(*((integer8 *) (*(*l_element_courant).donnee).objet)) =
				(indice_i % (*((struct_vecteur *) (*s_objet_2).objet)).taille)
				+ 1;
	}

/*
--------------------------------------------------------------------------------
  Traitement des éléments des matrices
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_2).type == MIN) ||
			((*s_objet_2).type == MRL) ||
			((*s_objet_2).type == MCX))
	{
		if ((*s_objet_1).type != LST)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;
		nombre_dimensions = 0;

		while(l_element_courant != NULL)
		{
			nombre_dimensions++;
			l_element_courant = (*l_element_courant).suivant;
		}

		if (nombre_dimensions != 2)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		l_element_courant = (*s_objet_1).objet;

		indice_i = 0;
		indice_j = 0;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
			{
				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if (indice_i == 0)
			{
				indice_i = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}
			else
			{
				indice_j = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet))
				.nombre_lignes) || (indice_j > (*((struct_matrice *)
				(*s_objet_2).objet)).nombre_colonnes))
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		if ((*s_objet_2).type == MIN)
		{
			/*
			 * Matrice d'entiers
			 */

			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_matrice *) (*s_objet_2).objet))
					.tableau)[indice_i - 1][indice_j - 1];
		}
		else if ((*s_objet_2).type == MRL)
		{
			/*
			 * Matrice de réels
			 */

			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_matrice *) (*s_objet_2).objet))
					.tableau)[indice_i - 1][indice_j - 1];
		}
		else
		{
			/*
			 * Matrices de complexes
			 */

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

			(*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
					((struct_complexe16 **) (*((struct_matrice *)
					(*s_objet_2).objet)).tableau)[indice_i - 1]
					[indice_j - 1].partie_reelle;
			(*((struct_complexe16 *) (*s_objet_resultat).objet))
					.partie_imaginaire = ((struct_complexe16 **)
					(*((struct_matrice *) (*s_objet_2).objet)).tableau)
					[indice_i - 1][indice_j - 1].partie_imaginaire;
		}


		if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
				(*s_objet_1).objet)).suivant).donnee).objet))) >
				(integer8) (*((struct_matrice *) (*s_objet_2).objet))
				.nombre_colonnes)
		{
			(*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
					.objet)).suivant).donnee).objet)) = 1;

			if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
					(*s_objet_1).objet)).donnee).objet))) >
					(integer8) (*((struct_matrice *) (*s_objet_2).objet))
					.nombre_lignes)
			{
				(*((integer8 *) (*(*((struct_liste_chainee *)
						(*s_objet_1).objet)).donnee).objet)) = 1;
			}
		}
	}

/*
--------------------------------------------------------------------------------
  Traitement des listes
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == LST)
	{
		if ((*s_objet_1).type != INT)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		nombre_elements = 0;
		l_element_courant = (*s_objet_2).objet;

		while(l_element_courant != NULL)
		{
			l_element_courant = (*l_element_courant).suivant;
			nombre_elements++;
		}

		indice_i = (*((integer8 *) (*s_objet_1).objet));
		indice_j = 1;
		l_element_courant = (*s_objet_2).objet;

		while((l_element_courant != NULL) && (indice_j != indice_i))
		{
			l_element_courant = (*l_element_courant).suivant;
			indice_j++;
		}

		if (l_element_courant != NULL)
		{
			if ((s_objet_resultat = copie_objet(s_etat_processus,
					(*l_element_courant).donnee, 'O')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}
		else
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		(*((integer8 *) (*s_objet_1).objet)) =
				(indice_i % nombre_elements) + 1;
	}

/*
--------------------------------------------------------------------------------
  Traitement des variables
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_2).type == NOM)
	{
		variable_partagee = d_faux;

		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_2).objet)).nom) == d_faux)
		{
			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;

			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

			return;
		}

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

		if (s_objet_3 == NULL)
		{
			if (recherche_variable_partagee(s_etat_processus,
					(*(*s_etat_processus).pointeur_variable_courante).nom,
					(*(*s_etat_processus).pointeur_variable_courante)
					.variable_partagee, (*(*s_etat_processus)
					.pointeur_variable_courante).origine) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es;
				(*s_etat_processus).erreur_execution =
						d_ex_variable_non_definie;

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

				return;
			}

			s_objet_3 = (*(*s_etat_processus)
					.pointeur_variable_partagee_courante).objet;
			variable_partagee = d_vrai;
		}

		if (((*s_objet_3).type == VIN) ||
				((*s_objet_3).type == VRL) ||
				((*s_objet_3).type == VCX))
		{
			if ((*s_objet_1).type != LST)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;
			nombre_dimensions = 0;

			while(l_element_courant != NULL)
			{
				nombre_dimensions++;
				l_element_courant = (*l_element_courant).suivant;
			}

			if (nombre_dimensions != 1)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;

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

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

				(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
				return;
			}
			else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
					(integer8) (*((struct_vecteur *) (*s_objet_3).objet))
					.taille)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((*s_objet_3).type == VIN)
			{
				/*
				 * Vecteur d'entiers
				 */

				if ((s_objet_resultat = 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;
						}
					}

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

				(*((integer8 *) (*s_objet_resultat).objet)) =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_3).objet)).tableau)[indice_i - 1];
			}
			else if ((*s_objet_3).type == VRL)
			{
				/*
				 * Vecteur de réels
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, REL))
						== 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;
						}
					}

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
						.tableau)[indice_i - 1];
			}
			else
			{
				/*
				 * Vecteur de complexes
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, CPL))
						== 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;
						}
					}

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

				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_reelle = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_3).objet))
						.tableau)[indice_i - 1].partie_reelle;
				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_imaginaire = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_3).objet)).tableau)
						[indice_i - 1].partie_imaginaire;
			}

			(*((integer8 *) (*(*l_element_courant).donnee).objet)) =
					(indice_i % (*((struct_vecteur *) (*s_objet_3).objet))
					.taille) + 1;
		}
		else if (((*s_objet_3).type == MIN) ||
				((*s_objet_3).type == MRL) ||
				((*s_objet_3).type == MCX))
		{
			if ((*s_objet_1).type != LST)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;
			nombre_dimensions = 0;

			while(l_element_courant != NULL)
			{
				nombre_dimensions++;
				l_element_courant = (*l_element_courant).suivant;
			}

			if (nombre_dimensions != 2)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			l_element_courant = (*s_objet_1).objet;

			indice_i = 0;
			indice_j = 0;

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type != INT)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				if ((*((integer8 *) (*(*l_element_courant)
						.donnee).objet)) <= 0)
				{
					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;
						}
					}

					liberation(s_etat_processus, s_objet_1);
					liberation(s_etat_processus, s_objet_2);

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

				if (indice_i == 0)
				{
					indice_i = (*((integer8 *)
							(*(*l_element_courant).donnee).objet));
				}
				else
				{
					indice_j = (*((integer8 *)
							(*(*l_element_courant).donnee).objet));
				}

				l_element_courant = (*l_element_courant).suivant;
			}

			if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
					.nombre_lignes) || (indice_j > (*((struct_matrice *)
					(*s_objet_3).objet)).nombre_colonnes))
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			if ((*s_objet_3).type == MIN)
			{
				/*
				 * Matrice d'entiers
				 */

				if ((s_objet_resultat = 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;
						}
					}

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

				(*((integer8 *) (*s_objet_resultat).objet)) =
						((integer8 **) (*((struct_matrice *)
						(*s_objet_3).objet))
						.tableau)[indice_i - 1][indice_j - 1];
			}
			else if ((*s_objet_3).type == MRL)
			{
				/*
				 * Matrice de réels
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, REL))
						== 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;
						}
					}

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
						.tableau)[indice_i - 1][indice_j - 1];
			}
			else
			{
				/*
				 * Matrices de complexes
				 */

				if ((s_objet_resultat = allocation(s_etat_processus, CPL))
						== 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;
						}
					}

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

				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_reelle = ((struct_complexe16 **)
						(*((struct_matrice *)
						(*s_objet_3).objet)).tableau)[indice_i - 1]
						[indice_j - 1].partie_reelle;
				(*((struct_complexe16 *) (*s_objet_resultat).objet))
						.partie_imaginaire = ((struct_complexe16 **)
						(*((struct_matrice *) (*s_objet_3).objet)).tableau)
						[indice_i - 1][indice_j - 1].partie_imaginaire;
			}

			if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
					(*s_objet_1).objet)).suivant).donnee).objet))) >
					(integer8) (*((struct_matrice *) (*s_objet_3).objet))
					.nombre_colonnes)
			{
				(*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
						.objet)).suivant).donnee).objet)) = 1;

				if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
						(*s_objet_1).objet)).donnee).objet))) >
						(integer8) (*((struct_matrice *) (*s_objet_3).objet))
						.nombre_lignes)
				{
					(*((integer8 *) (*(*((struct_liste_chainee *)
							(*s_objet_1).objet)).donnee).objet)) = 1;
				}
			}
		}
		else if ((*s_objet_3).type == LST)
		{
			if ((*s_objet_1).type != INT)
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			nombre_elements = 0;
			l_element_courant = (*s_objet_3).objet;

			while(l_element_courant != NULL)
			{
				l_element_courant = (*l_element_courant).suivant;
				nombre_elements++;
			}

			indice_i = (*((integer8 *) (*s_objet_1).objet));
			indice_j = 1;
			l_element_courant = (*s_objet_3).objet;

			while((l_element_courant != NULL) && (indice_j != indice_i))
			{
				l_element_courant = (*l_element_courant).suivant;
				indice_j++;
			}

			if (l_element_courant != NULL)
			{
				if ((s_objet_resultat = copie_objet(s_etat_processus,
						(*l_element_courant).donnee, 'O')) == 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;
						}
					}

					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}
			}
			else
			{
				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;
					}
				}

				liberation(s_etat_processus, s_objet_1);
				liberation(s_etat_processus, s_objet_2);

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

			(*((integer8 *) (*s_objet_1).objet)) =
					(indice_i % nombre_elements) + 1;
		}
		else
		{
			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;
				}
			}

			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

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

/*
--------------------------------------------------------------------------------
  Type incompatible avec la fonction GETI
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_1);
		liberation(s_etat_processus, s_objet_2);

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

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

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

	if ((*s_objet_resultat).type == NOM)
	{
		if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
		{
			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
			{
				return;
			}
		}
		else
		{
			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_resultat) == d_erreur)
			{
				return;
			}
		}
	}
	else if ((*s_objet_resultat).type == FCT)
	{
		registre_test = (*s_etat_processus).test_instruction;
		registre_instruction_courante = (*s_etat_processus)
				.instruction_courante;
		registre_instruction_valide = (*s_etat_processus)
				.instruction_valide;

		(*s_etat_processus).test_instruction = 'Y';
		(*s_etat_processus).instruction_courante =
				(*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;

		analyse(s_etat_processus, NULL);

		(*s_etat_processus).test_instruction = registre_test;
		(*s_etat_processus).instruction_courante =
				registre_instruction_courante;

		if (((*s_etat_processus).instruction_valide == 'Y') &&
				(*s_etat_processus).constante_symbolique == 'Y')
		{
			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
			{
				(*s_etat_processus).instruction_valide =
						registre_instruction_valide;
				return;
			}
		}
		else
		{
			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_resultat) == d_erreur)
			{
				(*s_etat_processus).instruction_valide =
						registre_instruction_valide;
				return;
			}
		}

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

	return;
}

// vim: ts=4