/*
================================================================================
  RPL/2 (R) version 4.1.30
  Copyright (C) 1989-2018 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


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

void
instruction_col_plus(struct_processus *s_etat_processus)
{
	integer8						position;

	logical1						presence_nom;
	logical1						variable_partagee;

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

	void							*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(ajout d'une colonne dans une matrice)\n\n");
		}
		else
		{
			printf("(add a column 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 (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_colonnes
			!= 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)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*(*s_etat_processus).pointeur_variable_courante).objet == 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;
			}

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

	if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
			!= (*((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);

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

		if (presence_nom == d_faux)
		{
			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)
	{
		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 ((*s_objet_argument_1).type == MRL)
	{
		if ((*s_copie_argument_3).type == MIN)
		{
			// Conversion de la matrice entière en matrice réelle

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_copie_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_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j] = (real8) (((integer8 *)
							tampon)[j]);
				}

				free(tampon);
			}

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_copie_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_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j].partie_reelle =
							(real8) (((integer8 *) tampon)[j]);
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc(((size_t) (*((struct_matrice *)
						(*s_copie_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_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j].partie_reelle =
							((real8 *) tampon)[j];
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}

				free(tampon);
			}

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

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

	if ((*s_copie_argument_3).type == MIN)
	{
		if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_copie_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);
			liberation(s_etat_processus, s_objet_argument_3);

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

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

		if ((position < 1) || (position > (*((struct_matrice *)
				(*s_copie_argument_3).objet)).nombre_colonnes + 1))
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

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

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

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

			if (((*((struct_matrice *) (*s_copie_argument_3).objet)).tableau[i]
					= malloc((((size_t) (*((struct_matrice *)
					(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
					sizeof(integer8))) == 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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
					.objet)).nombre_colonnes; j++)
			{
				if (j == (position - 1))
				{
					((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j] = ((integer8 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][0];
					l = 1;
				}

				((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).tableau)[i][j + l] = ((integer8 *) tampon)[j];
			}

			if (l == 0)
			{
				((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).tableau)[i][(*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes] =
						((integer8 **) (*((struct_matrice *)
						(*s_objet_argument_1).objet)).tableau)[i][0];
			}

			free(tampon);
		}

		(*((struct_matrice *) (*s_copie_argument_3).objet)).nombre_colonnes++;
	}
	else if ((*s_copie_argument_3).type == MRL)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_copie_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);
				liberation(s_etat_processus, s_objet_argument_3);

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

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

			if ((position < 1) || (position >
					(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes + 1))
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc((((size_t) (*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
						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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					if (j == (position - 1))
					{
						((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
								.objet)).tableau)[i][j] = (real8) ((integer8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0];
						l = 1;
					}

					((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l] = ((real8 *) tampon)[j];
				}

				if (l == 0)
				{
					((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes] =
							(real8) ((integer8 **) (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau)[i][0];
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes++;
		}
		else // Matrice réelle
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_copie_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);
				liberation(s_etat_processus, s_objet_argument_3);

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

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

			if ((position < 1) || (position >
					(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes + 1))
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc((((size_t) (*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
						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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					if (j == (position - 1))
					{
						((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
								.objet)).tableau)[i][j] = ((real8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0];
						l = 1;
					}

					((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l] = ((real8 *) tampon)[j];
				}

				if (l == 0)
				{
					((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes] =
							((real8 **) (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau)[i][0];
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes++;
		}
	}
	else if ((*s_copie_argument_3).type == MCX)
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_copie_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);
				liberation(s_etat_processus, s_objet_argument_3);

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

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

			if ((position < 1) || (position > (*((struct_matrice *)
					(*s_copie_argument_3).objet)).nombre_colonnes + 1))
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc((((size_t) (*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
						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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					if (j == (position - 1))
					{
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_reelle = (real8) ((integer8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0];
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_imaginaire = 0;
						l = 1;
					}

					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_reelle =
							((complex16 *) tampon)[j].partie_reelle;
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_imaginaire =
							((complex16 *) tampon)[j].partie_imaginaire;
				}

				if (l == 0)
				{
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_reelle = (real8) ((integer8 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][0];
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes++;
		}
		else if ((*s_objet_argument_1).type == MRL)
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_copie_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);
				liberation(s_etat_processus, s_objet_argument_3);

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

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

			if ((position < 1) || (position > (*((struct_matrice *)
					(*s_copie_argument_3).objet)).nombre_colonnes + 1))
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc((((size_t) (*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
						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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					if (j == (position - 1))
					{
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_reelle = ((real8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0];
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_imaginaire = 0;
						l = 1;
					}

					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_reelle =
							((complex16 *) tampon)[j].partie_reelle;
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_imaginaire =
							((complex16 *) tampon)[j].partie_imaginaire;
				}

				if (l == 0)
				{
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_reelle = ((real8 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][0];
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_imaginaire = 0;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes++;
		}
		else // Matrice complexe
		{
			if ((*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_lignes != (*((struct_matrice *)
					(*s_copie_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);
				liberation(s_etat_processus, s_objet_argument_3);

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

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

			if ((position < 1) || (position > (*((struct_matrice *)
					(*s_copie_argument_3).objet)).nombre_colonnes + 1))
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

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

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

				if (((*((struct_matrice *) (*s_copie_argument_3).objet))
						.tableau[i] = malloc((((size_t) (*((struct_matrice *)
						(*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
						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(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
						.objet)).nombre_colonnes; j++)
				{
					if (j == (position - 1))
					{
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_reelle = ((complex16 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0].partie_reelle;
						((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_3).objet)).tableau)[i][j]
						   		.partie_imaginaire = ((complex16 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][0].partie_imaginaire;
						l = 1;
					}

					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_reelle =
							((complex16 *) tampon)[j].partie_reelle;
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][j + l].partie_imaginaire =
							((complex16 *) tampon)[j].partie_imaginaire;
				}

				if (l == 0)
				{
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_reelle = ((complex16 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][0].partie_reelle;
					((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
							.objet)).tableau)[i][(*((struct_matrice *)
							(*s_copie_argument_3).objet)).nombre_colonnes]
							.partie_imaginaire = ((complex16 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][0].partie_imaginaire;
				}

				free(tampon);
			}

			(*((struct_matrice *) (*s_copie_argument_3).objet))
					.nombre_colonnes++;
		}
	}
	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 (presence_nom == d_faux)
		{
			liberation(s_etat_processus, s_copie_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_copie_argument_3) == d_erreur)
		{
			return;
		}
	}
	else
	{
		if (variable_partagee == d_faux)
		{
			(*(*s_etat_processus).pointeur_variable_courante).objet =
					s_copie_argument_3;
		}
		else
		{
			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
					s_copie_argument_3;
			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;

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

	return;
}


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

void
instruction_col_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					k;
	integer8					colonne;

	void						*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(retrait d'une colonne dans une matrice)\n\n");
		}
		else
		{
			printf("(remove a column 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)
	{
		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument_2).objet)).nom) == d_faux)
		{
			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;

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

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

		if ((*(*s_etat_processus).pointeur_variable_courante).objet == 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;
			}

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

		presence_variable = d_vrai;
	}
	else
	{
		presence_variable = d_faux;
	}

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

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

			if ((position <= 0) || (position > (*((struct_matrice *)
					(*s_copie_argument_2).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_variable == d_faux)
				{
					liberation(s_etat_processus, s_copie_argument_2);
				}

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

			if ((s_objet_resultat = allocation(s_etat_processus, NON))
					== 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 (((*s_objet_resultat).objet =
					malloc(sizeof(struct_matrice))) == 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_colonnes =
					1;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					(*((struct_matrice *) (*s_copie_argument_2).objet))
					.nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).type =
					(*((struct_matrice *) (*s_copie_argument_2).objet)).type;

			switch((*((struct_matrice *) (*s_objet_resultat).objet)).type)
			{
				case 'I' :
				{
					(*s_objet_resultat).type = MIN;

					if (((*((struct_matrice *) (*s_objet_resultat).objet))
							.tableau = malloc(((size_t) (*((struct_matrice *)
							(*s_objet_resultat).objet)).nombre_lignes) *
							sizeof(integer8 *))) == 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(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						if (((*((struct_matrice *) (*s_objet_resultat).objet))
								.tableau[i] = malloc(sizeof(integer8))) == 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;
						}

					}

					colonne = position - 1;

					for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						((integer8 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][0] =
								((integer8 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet))
								.tableau)[i][colonne];

						tampon = ((integer8 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet)).tableau)[i];

						if ((((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).tableau)[i] = malloc(((size_t)
								((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).nombre_colonnes) - 1) *
								sizeof(integer8))) == 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 = k = 0; j < (*((struct_matrice *)
								(*s_copie_argument_2).objet)).nombre_colonnes
								- 1; j++)
						{
							if (j == colonne)
							{
								k = 1;
							}

							((integer8 **) (*((struct_matrice *)
									(*s_copie_argument_2).objet)).tableau)
									[i][j] = ((integer8 *) tampon)[j + k];
						}

						free(tampon);
					}

					(*((struct_matrice *) (*s_copie_argument_2).objet))
							.nombre_colonnes--;
					break;
				}

				case 'R' :
				{
					(*s_objet_resultat).type = MRL;

					if (((*((struct_matrice *) (*s_objet_resultat).objet))
							.tableau = malloc(((size_t) (*((struct_matrice *)
							(*s_objet_resultat).objet)).nombre_lignes) *
							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(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						if (((*((struct_matrice *) (*s_objet_resultat).objet))
								.tableau[i] = malloc(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;
						}

					}

					colonne = position - 1;

					for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						((real8 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][0] =
								((real8 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet))
								.tableau)[i][colonne];

						tampon = ((real8 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet)).tableau)[i];

						if ((((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).tableau)[i] = malloc(((size_t)
								((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).nombre_colonnes) - 1) *
								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 = k = 0; j < (*((struct_matrice *)
								(*s_copie_argument_2).objet)).nombre_colonnes
								- 1; j++)
						{
							if (j == colonne)
							{
								k = 1;
							}

							((real8 **) (*((struct_matrice *)
									(*s_copie_argument_2).objet)).tableau)
									[i][j] = ((real8 *) tampon)[j + k];
						}

						free(tampon);
					}

					(*((struct_matrice *) (*s_copie_argument_2).objet))
							.nombre_colonnes--;
					break;
				}

				case 'C' :
				{
					(*s_objet_resultat).type = MCX;

					if (((*((struct_matrice *) (*s_objet_resultat).objet))
							.tableau = malloc(((size_t) (*((struct_matrice *)
							(*s_objet_resultat).objet)).nombre_lignes) *
							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(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						if (((*((struct_matrice *) (*s_objet_resultat).objet))
								.tableau[i] = malloc(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;
						}

					}

					colonne = position - 1;

					for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
							.objet)).nombre_lignes; i++)
					{
						((complex16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][0]
								.partie_reelle =
								((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet))
								.tableau)[i][colonne].partie_reelle;
						((complex16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][0]
								.partie_imaginaire =
								((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet))
								.tableau)[i][colonne].partie_imaginaire;

						tampon = ((complex16 **) (*((struct_matrice *)
								(*s_copie_argument_2).objet)).tableau)[i];

						if ((((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).tableau)[i] = malloc(((size_t)
								((*((struct_matrice *) (*s_copie_argument_2)
								.objet)).nombre_colonnes) - 1) *
								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 = k = 0; j < (*((struct_matrice *)
								(*s_copie_argument_2).objet)).nombre_colonnes
								- 1; j++)
						{
							if (j == colonne)
							{
								k = 1;
							}

							((complex16 **) (*((struct_matrice *)
									(*s_copie_argument_2).objet)).tableau)
									[i][j].partie_reelle = ((complex16 *)
									tampon)[j + k].partie_reelle;
							((complex16 **) (*((struct_matrice *)
									(*s_copie_argument_2).objet)).tableau)
									[i][j].partie_imaginaire = ((complex16 *)
									tampon)[j + k].partie_imaginaire;
						}

						free(tampon);
					}

					(*((struct_matrice *) (*s_copie_argument_2).objet))
							.nombre_colonnes--;
					break;
				}
			}
		}
		else
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

			(*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);

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

		(*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 (presence_variable == d_faux)
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_copie_argument_2) == d_erreur)
		{
			return;
		}
	}
	else
	{
		if (variable_partagee == d_faux)
		{
			(*(*s_etat_processus).pointeur_variable_courante).objet =
					s_copie_argument_2;
		}
		else
		{
			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
					s_copie_argument_2;
			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;

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

// vim: ts=4