/*
================================================================================
  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 'pcov'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_pcov(struct_processus *s_etat_processus)
{
	integer8							nombre_colonnes;

	logical1							erreur;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(covariance d'une population)\n\n");
		}
		else
		{
			printf("(population covariance)\n\n");
		}

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

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

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

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

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

		(*s_etat_processus).erreur_systeme = d_es;

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

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

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

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

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if (((*s_etat_processus).colonne_statistique_1 < 1) ||
				((*s_etat_processus).colonne_statistique_2 < 1) ||
				((*s_etat_processus).colonne_statistique_1 > nombre_colonnes) ||
				((*s_etat_processus).colonne_statistique_2 > nombre_colonnes))
		{
			(*s_etat_processus).erreur_execution =
					d_ex_observations_inexistantes;
			return;
		}

		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)) = covariance_statistique(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_1,
				(*s_etat_processus).colonne_statistique_2, 'N', &erreur);

		if (erreur == d_erreur)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
	}
	else
	{
		(*s_etat_processus).erreur_execution =
				d_ex_matrice_statistique_invalide;
		return;
	}

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

	return;
}


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

void
instruction_prlcd(struct_processus *s_etat_processus)
{
	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(impression puis destruction de la file graphique)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(print and purge the graphical queue)\n\n");
			printf("  No argument\n");
		}

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

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

	appel_gnuplot(s_etat_processus, 'I');

	(*s_etat_processus).exception = d_ep;

	return;
}


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

void
instruction_putc(struct_processus *s_etat_processus)
{
	integer8						position;

	logical1						presence_nom;
	logical1						variable_partagee;

	struct_liste_chainee			*l_element_courant;

	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;
	integer8						nombre_elements;

	void							*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(change une colonne)\n\n");
		}
		else
		{
			printf("(change column)\n\n");
		}

		printf("    3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    2: %s\n", d_LST);
		printf("    1: %s, %s, %s\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_LST);
		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 != 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 ((*s_objet_argument_2).type != LST)
	{
		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;
	}

	nombre_elements = 0;
	l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet;

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

		nombre_elements++;
		l_element_courant = (*l_element_courant).suivant;
	}

	if ((nombre_elements == 0) || (nombre_elements != (*((struct_matrice *)
			(*s_objet_argument_1).objet)).nombre_colonnes))
	{
		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;
	}

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

		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);
			liberation(s_etat_processus, s_objet_argument_3);

			return;
		}

		liberation(s_etat_processus, s_objet_argument_3);
		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, 'O')) == 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;

		(*(*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, 'O')) == 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 ((*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 == MIN)
	{
		if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_objet_argument_3).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);
			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;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_2).objet;
		i = 0;

		while(l_element_courant != NULL)
		{
			position = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((position < 1) || (position > (integer8) (*((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_argument_invalide;
				return;
			}

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

			l_element_courant = (*l_element_courant).suivant;
			i++;
		}
	}
	else if ((*s_objet_argument_3).type == MRL)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((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_erreur_type_argument;
					return;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else // Matrice réelle
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((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_argument_invalide;
					return;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
	}
	else if ((*s_objet_argument_3).type == MCX)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((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_argument_invalide;
					return;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else if ((*s_objet_argument_1).type == MRL)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((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_argument_invalide;
					return;
				}

				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
						.objet)).nombre_lignes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[j][position - 1].partie_reelle =
							((real8 **) (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau)[j][i];
					((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
							.objet)).tableau)[j][position - 1]
							.partie_imaginaire = 0;
				}

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else // Matrice complexe
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((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_argument_invalide;
					return;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
	}
	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);
		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_erreur_type_argument;
		return;
	}

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

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

	return;
}


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

void
instruction_putr(struct_processus *s_etat_processus)
{
	integer8						position;

	logical1						presence_nom;
	logical1						variable_partagee;

	struct_liste_chainee			*l_element_courant;

	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;
	integer8						nombre_elements;

	void							*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(change une ligne)\n\n");
		}
		else
		{
			printf("(change row)\n\n");
		}

		printf("    3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    2: %s\n", d_LST);
		printf("    1: %s, %s, %s\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_LST);
		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 != 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 ((*s_objet_argument_2).type != LST)
	{
		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;
	}

	nombre_elements = 0;
	l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet;

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

		nombre_elements++;
		l_element_courant = (*l_element_courant).suivant;
	}

	if ((nombre_elements == 0) || (nombre_elements != (*((struct_matrice *)
			(*s_objet_argument_1).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;
	}

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

		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);
			liberation(s_etat_processus, s_objet_argument_3);

			return;
		}

		liberation(s_etat_processus, s_objet_argument_3);
		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 ((*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 == MIN)
	{
		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;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_2).objet;
		i = 0;

		while(l_element_courant != NULL)
		{
			position = (*((integer8 *) (*(*l_element_courant).donnee).objet));

			if ((position < 1) || (position > (integer8) (*((struct_matrice *)
					(*s_objet_argument_3).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);
				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;
			}

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

			l_element_courant = (*l_element_courant).suivant;
			i++;
		}
	}
	else if ((*s_objet_argument_3).type == MRL)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((struct_matrice *) (*s_objet_argument_3).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);
					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;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else // Matrice réelle
		{
			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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((struct_matrice *) (*s_objet_argument_3).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);
					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;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
	}
	else if ((*s_objet_argument_3).type == MCX)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((struct_matrice *) (*s_objet_argument_3).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);
					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;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else if ((*s_objet_argument_1).type == MRL)
		{
			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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((struct_matrice *) (*s_objet_argument_3).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);
					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;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
		else // Matrice complexe
		{
			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;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			i = 0;

			while(l_element_courant != NULL)
			{
				position = (*((integer8 *) (*(*l_element_courant)
						.donnee).objet));

				if ((position < 1) || (position > (integer8)
						(*((struct_matrice *) (*s_objet_argument_3).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);
					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;
				}

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

				l_element_courant = (*l_element_courant).suivant;
				i++;
			}
		}
	}
	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);
		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_erreur_type_argument;
		return;
	}

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

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

	return;
}

// vim: ts=4