/*
================================================================================
  RPL/2 (R) version 4.1.32
  Copyright (C) 1989-2020 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 'rswp'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_rswp(struct_processus *s_etat_processus)
{
	struct_objet				*s_copie_argument_3;
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_argument_3;

	integer8					ligne_1;
	integer8					ligne_2;

	void						*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(échange de deux lignes d'une matrice)\n\n");
		}
		else
		{
			printf("(swap two rows of a matrix)\n\n");
		}

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

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_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_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_3) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	if (((*s_objet_argument_1).type == INT) &&
			((*s_objet_argument_2).type == INT))
	{
		if (((*s_objet_argument_3).type == MIN) ||
				((*s_objet_argument_3).type == MRL) ||
				((*s_objet_argument_3).type == MCX))
		{
			ligne_1 = (*((integer8 *) (*s_objet_argument_1).objet)) - 1;
			ligne_2 = (*((integer8 *) (*s_objet_argument_2).objet)) - 1;

			if ((ligne_1 < 0) || (ligne_1 >= (*((struct_matrice *)
					(*s_objet_argument_3).objet)).nombre_lignes) ||
					(ligne_2 < 0) || (ligne_2 >= (*((struct_matrice *)
					(*s_objet_argument_3).objet)).nombre_lignes))
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_argument_3);

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

			if ((s_copie_argument_3 = copie_objet(s_etat_processus,
					s_objet_argument_3, 'Q')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			liberation(s_etat_processus, s_objet_argument_3);
			s_objet_argument_3 = s_copie_argument_3;

			tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
					.tableau[ligne_1];
			(*((struct_matrice *) (*s_objet_argument_3).objet)).tableau[ligne_1]
					= (*((struct_matrice *) (*s_objet_argument_3).objet))
					.tableau[ligne_2];
			(*((struct_matrice *) (*s_objet_argument_3).objet)).tableau[ligne_2]
					= tampon;
		}
		else
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

	return;
}


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

void
instruction_row_plus(struct_processus *s_etat_processus)
{
	integer8						position;

	logical1						matrice_vide;
	logical1						presence_nom;
	logical1						variable_partagee;

	struct_objet					*s_copie_argument_1;
	struct_objet					*s_copie_argument_3;
	struct_objet					*s_objet_argument_1;
	struct_objet					*s_objet_argument_2;
	struct_objet					*s_objet_argument_3;

	integer8						i;
	integer8						j;

	void							**tableau;
	void							*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(ajout d'une ligne dans une matrice)\n\n");
		}
		else
		{
			printf("(add a row in a matrix)\n\n");
		}

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

		printf("    3: %s\n", d_NOM);
		printf("    2: %s\n", d_INT);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);

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

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

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

	liberation(s_etat_processus, s_objet_argument_1);
	s_objet_argument_1 = s_copie_argument_1;

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_3) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	if (((*s_objet_argument_1).type != MIN) &&
			((*s_objet_argument_1).type != MRL) &&
		   	((*s_objet_argument_1).type != MCX))
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

	if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
			!= 1)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

	if ((*s_objet_argument_2).type != INT)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

	variable_partagee = d_faux;

	if ((*s_objet_argument_3).type == NOM)
	{
		presence_nom = d_vrai;

		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument_3).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_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

			return;
		}

		liberation(s_etat_processus, s_objet_argument_3);

		if ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_verrouillee == d_vrai)
		{
			(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			return;
		}

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

		if (s_objet_argument_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_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);

				return;
			}

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

		if ((s_copie_argument_3 = copie_objet(s_etat_processus,
				s_objet_argument_3, 'Q')) == 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;
		}

		liberation(s_etat_processus, s_objet_argument_3);
		s_objet_argument_3 = s_copie_argument_3;

		(*(*s_etat_processus).pointeur_variable_courante).objet =
				s_objet_argument_3;
	}
	else
	{
		presence_nom = d_faux;

		if ((s_copie_argument_3 = copie_objet(s_etat_processus,
				s_objet_argument_3, 'Q')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		liberation(s_etat_processus, s_objet_argument_3);
		s_objet_argument_3 = s_copie_argument_3;
	}

	if (((*((struct_matrice *) (*s_objet_argument_3).objet)).nombre_colonnes
			== 0) && ((*((struct_matrice *) (*s_objet_argument_3).objet))
			.nombre_lignes == 1))
	{
		matrice_vide = d_vrai;
	}
	else
	{
		matrice_vide = d_faux;

		if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_colonnes
				!= (*((struct_matrice *) (*s_objet_argument_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_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			if (presence_nom == d_faux)
			{
				liberation(s_etat_processus, s_objet_argument_3);
			}

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

	if ((*s_objet_argument_1).type == MRL)
	{
		if ((*s_objet_argument_3).type == MIN)
		{
			// Conversion de la matrice entière en matrice réelle

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_3).objet)).nombre_colonnes) *
						sizeof(real8))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[i][j] = (real8) (((integer8 *)
							tampon)[j]);
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'R';
			(*s_objet_argument_3).type = MRL;
		}
	}
	else if ((*s_objet_argument_1).type == MCX)
	{
		if ((*s_objet_argument_3).type == MIN)
		{
			// Conversion de la matrice entière en matrice complexe

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_3).objet)).nombre_colonnes) *
						sizeof(complex16))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[i][j].partie_reelle =
							(real8) (((integer8 *) tampon)[j]);
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
			(*s_objet_argument_3).type = MCX;
		}
		else if ((*s_objet_argument_3).type == MRL)
		{
			// Conversion de la matrice réelle en matrice complexe

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_3).objet)).nombre_colonnes) *
						sizeof(complex16))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[i][j].partie_reelle =
							((real8 *) tampon)[j];
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
			(*s_objet_argument_3).type = MCX;
		}
	}	

	if ((*s_objet_argument_3).type == MRL)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			// Conversion de la matrice entière en matrice réelle

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_1).objet)).nombre_colonnes) *
						sizeof(real8))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
						.objet)).nombre_colonnes; j++)
				{
					((real8 **) (*((struct_matrice *) (*s_objet_argument_1)
							.objet)).tableau)[i][j] = (real8) (((integer8 *)
							tampon)[j]);
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_1).objet)).type = 'R';
			(*s_objet_argument_1).type = MRL;
		}
	}
	else if ((*s_objet_argument_3).type == MCX)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			// Conversion de la matrice entière en matrice complexe

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_1).objet)).nombre_colonnes) *
						sizeof(complex16))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_1)
							.objet)).tableau)[i][j].partie_reelle =
							(real8) (((integer8 *) tampon)[j]);
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_1)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_1).objet)).type = 'C';
			(*s_objet_argument_1).type = MCX;
		}
		else if ((*s_objet_argument_1).type == MRL)
		{
			// Conversion de la matrice réelle en matrice complexe

			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes; i++)
			{
				tampon = (*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i];

				if (((*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_objet_argument_1).objet)).nombre_colonnes) *
						sizeof(complex16))) == 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;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_1)
							.objet)).tableau)[i][j].partie_reelle =
							((real8 *) tampon)[j];
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_1)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_objet_argument_1).objet)).type = 'C';
			(*s_objet_argument_1).type = MCX;
		}
	}

	position = (*((integer8 *) (*s_objet_argument_2).objet));

	if (((position < 1) || (position > (integer8) ((*((struct_matrice *)
			(*s_objet_argument_3).objet)).nombre_lignes + 1))) ||
			((position != 1) && (matrice_vide == d_vrai)))
	{
		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_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

		if (presence_nom == d_faux)
		{
			liberation(s_etat_processus, s_objet_argument_3);
		}

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

	tableau = (*((struct_matrice *) (*s_objet_argument_3).objet)).tableau;

	if (matrice_vide == d_faux)
	{
		if (((*((struct_matrice *) (*s_objet_argument_3).objet)).tableau
				= malloc(((size_t) ((*((struct_matrice *) (*s_objet_argument_3)
				.objet)).nombre_lignes + 1)) * sizeof(void *))) == 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;
		}

		if (position != ((integer8) (*((struct_matrice *)
				(*s_objet_argument_3).objet)).nombre_lignes + 1))
		{
			for(j = i = 0; i < (*((struct_matrice *)
					(*s_objet_argument_3).objet)).nombre_lignes; i++)
			{
				if (i == (position - 1))
				{
					(*((struct_matrice *) (*s_objet_argument_3).objet))
							.tableau[i] = (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau[0];
					j = 1;
				}

				(*((struct_matrice *) (*s_objet_argument_3).objet))
						.tableau[i + j] = tableau[i];
			}
		}
		else
		{
			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
					.nombre_lignes; i++)
			{
				(*((struct_matrice *) (*s_objet_argument_3).objet)).tableau[i]
						= tableau[i];
			}

			(*((struct_matrice *) (*s_objet_argument_3).objet)).tableau
					[(*((struct_matrice *) (*s_objet_argument_3).objet))
					.nombre_lignes] = (*((struct_matrice *)
					(*s_objet_argument_1).objet)).tableau[0];
		}

		(*((struct_matrice *) (*s_objet_argument_3).objet)).nombre_lignes++;
	}
	else
	{
		free((*((struct_matrice *) (*s_objet_argument_3).objet)).tableau[0]);

		if (((*((struct_matrice *) (*s_objet_argument_3).objet)).tableau
				= malloc(sizeof(void *))) == 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_matrice *) (*s_objet_argument_3).objet)).tableau[0] =
				(*((struct_matrice *) (*s_objet_argument_1).objet)).tableau[0];
		(*((struct_matrice *) (*s_objet_argument_3).objet)).nombre_lignes =
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_lignes;
		(*((struct_matrice *) (*s_objet_argument_3).objet)).nombre_colonnes =
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_colonnes;
	}

	free(tableau);

	if (presence_nom == d_faux)
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument_3) == d_erreur)
		{
			return;
		}
	}
	else
	{
		if (variable_partagee == d_vrai)
		{
			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet
					= s_objet_argument_3;

			if (pthread_mutex_unlock(&((*(*s_etat_processus)
					.pointeur_variable_partagee_courante).mutex)) != 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}

	free((*((struct_matrice *) (*s_objet_argument_1).objet)).tableau);
	free((*s_objet_argument_1).objet);
	free(s_objet_argument_1);

	liberation(s_etat_processus, s_objet_argument_2);

	return;
}


/*
================================================================================
  Fonction 'row-'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_row_moins(struct_processus *s_etat_processus)
{
	integer8					position;

	logical1					presence_variable;
	logical1					variable_partagee;

	struct_objet				*s_copie_argument_2;
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat;

	integer8					i;
	integer8					j;
	integer8					colonne;

	void						**tableau;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(retrait d'une ligne dans une matrice)\n\n");
		}
		else
		{
			printf("(remove a row from a matrix)\n\n");
		}

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

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

		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_argument_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_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	variable_partagee = d_faux;

	if ((*s_objet_argument_2).type == NOM)
	{
		presence_variable = d_vrai;

		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument_2).objet)).nom) == d_faux)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

			return;
		}

		liberation(s_etat_processus, s_objet_argument_2);

		if ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_verrouillee == d_vrai)
		{
			liberation(s_etat_processus, s_objet_argument_1);

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

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

		if (s_objet_argument_2 == 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_argument_1);

				return;
			}

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

		if ((s_copie_argument_2 = copie_objet(s_etat_processus,
				s_objet_argument_2, 'Q')) == 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;
		}

		liberation(s_etat_processus, s_objet_argument_2);
		s_objet_argument_2 = s_copie_argument_2;

		(*(*s_etat_processus).pointeur_variable_courante).objet =
				s_objet_argument_2;
	}
	else
	{
		presence_variable = d_faux;

		if ((s_copie_argument_2 = copie_objet(s_etat_processus,
				s_objet_argument_2, 'Q')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		liberation(s_etat_processus, s_objet_argument_2);
		s_objet_argument_2 = s_copie_argument_2;
	}

	if (((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX))
	{
		if ((*s_objet_argument_1).type == INT)
		{
			position = (*((integer8 *) (*s_objet_argument_1).objet));

			if ((position <= 0) || (position > (integer8) (*((struct_matrice *)
					(*s_objet_argument_2).objet)).nombre_lignes))
			{
				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_argument_1);

				if (presence_variable == d_faux)
				{
					liberation(s_etat_processus, s_objet_argument_2);
				}

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

			if ((s_objet_resultat = allocation(s_etat_processus,
					(*s_objet_argument_2).type)) == 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_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					1;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					(*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_colonnes;

			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
					malloc(sizeof(void *))) == 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_matrice *) (*s_objet_resultat).objet)).tableau[0] =
					(*((struct_matrice *) (*s_objet_argument_2).objet)).tableau
					[colonne = position - 1];

			if ((*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_lignes > 1)
			{
				tableau = (*((struct_matrice *) (*s_objet_argument_2).objet))
						.tableau;

				if (((*((struct_matrice *) (*s_objet_argument_2).objet)).tableau
						= malloc(((size_t) ((*((struct_matrice *)
						(*s_objet_argument_2).objet)).nombre_lignes - 1)) *
						sizeof(void *))) == 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_matrice *) (*s_objet_argument_2).objet))
						.nombre_lignes--;

				for(i = j = 0; i < (*((struct_matrice *) (*s_objet_argument_2)
						.objet)).nombre_lignes; i++)
				{
					if (i == colonne)
					{
						j = 1;
					}

					(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau[i] = tableau[i + j];
				}

				free(tableau);
			}
			else
			{
				if (((*((struct_matrice *) (*s_objet_argument_2).objet))
						.tableau[0] = malloc(0)) == 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_matrice *) (*s_objet_argument_2).objet))
						.nombre_colonnes = 0;
			}
		}
		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_argument_1);

			if (presence_variable == d_faux)
			{
				liberation(s_etat_processus, s_objet_argument_2);
			}

			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
			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_argument_1);

		if (presence_variable == d_faux)
		{
			liberation(s_etat_processus, s_objet_argument_2);
		}

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

	liberation(s_etat_processus, s_objet_argument_1);

	if (presence_variable == d_faux)
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument_2) == d_erreur)
		{
			return;
		}
	}
	else if (variable_partagee == d_vrai)
	{
		(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
				s_objet_argument_2;

		if (pthread_mutex_unlock(&((*(*s_etat_processus)
				.pointeur_variable_partagee_courante).mutex)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

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

	return;
}


/*
================================================================================
  Fonction 'rci'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_rci(struct_processus *s_etat_processus)
{
	logical1					last_valide;

	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_argument_3;
	struct_objet				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(multiplication d'une ligne d'une matrice)\n\n");
		}
		else
		{
			printf("(multiply a row in a matrix)\n\n");
		}

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

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

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

		cf(s_etat_processus, 31);
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

		liberation(s_etat_processus, s_objet_argument_1);

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_3) == d_erreur)
	{
		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	if ((((*s_objet_argument_3).type == MIN) ||
			((*s_objet_argument_3).type == MRL) ||
			((*s_objet_argument_3).type == MCX)) &&
			(((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL) ||
			((*s_objet_argument_2).type == CPL)) &&
			((*s_objet_argument_1).type == INT))
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument_3) == d_erreur)
		{
			if (last_valide == d_vrai)
			{
				sf(s_etat_processus, 31);
			}

			return;
		}

		tampon = s_objet_argument_1;

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

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

		(*((struct_liste_chainee *) (*s_objet_argument_1).objet)).donnee =
				tampon;
		(*((struct_liste_chainee *) (*s_objet_argument_1).objet)).suivant =
				NULL;

		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument_1) == d_erreur)
		{
			if (last_valide == d_vrai)
			{
				sf(s_etat_processus, 31);
			}

			return;
		}

		instruction_dup2(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

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

			return;
		}

		instruction_getr(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

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

			return;
		}

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

		instruction_multiplication(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

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

			return;
		}

		instruction_putr(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);

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

			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

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

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

	return;
}


/*
================================================================================
  Fonction 'rcij'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_rcij(struct_processus *s_etat_processus)
{
	logical1					last_valide;

	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_argument_3;
	struct_objet				*s_objet_argument_4;
	struct_objet				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(multiplication puis ajout d'une ligne d'une matrice)\n\n");
		}
		else
		{
			printf("(multiply and add a row in a matrix)\n\n");
		}

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

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

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

		cf(s_etat_processus, 31);
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_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_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_3) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_4) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);

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

	if ((((*s_objet_argument_4).type == MIN) ||
			((*s_objet_argument_4).type == MRL) ||
			((*s_objet_argument_4).type == MCX)) &&
			(((*s_objet_argument_3).type == INT) ||
			((*s_objet_argument_3).type == REL) ||
			((*s_objet_argument_3).type == CPL)) &&
			((*s_objet_argument_2).type == INT) &&
			((*s_objet_argument_1).type == INT))
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument_4) == d_erreur)
		{
			return;
		}

		tampon = s_objet_argument_1;

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

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

		(*((struct_liste_chainee *) (*s_objet_argument_1).objet)).donnee =
				tampon;
		(*((struct_liste_chainee *) (*s_objet_argument_1).objet)).suivant =
				NULL;

		tampon = s_objet_argument_2;

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

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

		(*((struct_liste_chainee *) (*s_objet_argument_2).objet)).donnee =
				tampon;
		(*((struct_liste_chainee *) (*s_objet_argument_2).objet)).suivant =
				NULL;

		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))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

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

		instruction_getr(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

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

		instruction_multiplication(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_over(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

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

		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))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_over(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_getr(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_rot(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_plus(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}

		instruction_putr(s_etat_processus);

		if (((*s_etat_processus).erreur_systeme != d_es) ||
				((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);
		liberation(s_etat_processus, s_objet_argument_3);
		liberation(s_etat_processus, s_objet_argument_4);

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

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

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

	return;
}

// vim: ts=4