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

void
instruction_cycle(struct_processus *s_etat_processus)
{
	logical1						drapeau_presence_fin_boucle;
	logical1						erreur;
	logical1						presence_boucle;

	struct_liste_pile_systeme		*l_element_pile_systeme;

	unsigned char					*instruction_majuscule;
	unsigned char					*tampon;

	integer8						niveau;

	void							(*fonction)();

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(structure de contrôle)\n\n");
			printf("  Utilisation :\n\n");
		}
		else
		{
			printf("(control statement)\n\n");
			printf("  Usage:\n\n");
		}

		printf("    FOR (variable)\n");
		printf("        ...\n");
		printf("        CYCLE\n");
		printf("        ...\n");
		printf("    NEXT/STEP\n\n");

		printf("    FORALL (variable)\n");
		printf("        ...\n");
		printf("        CYCLE\n");
		printf("        ...\n");
		printf("    NEXT\n\n");

		printf("    START\n");
		printf("        ...\n");
		printf("        CYCLE\n");
		printf("        ...\n");
		printf("    NEXT/STEP\n");

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

	/*
	 * Test de la présence de l'instruction CYCLE dans une boucle définie
	 */
	
	l_element_pile_systeme = (*s_etat_processus).l_base_pile_systeme;
	presence_boucle = d_faux;

	while((l_element_pile_systeme != NULL) && (presence_boucle == d_faux))
	{
		if (((*l_element_pile_systeme).type_cloture == 'S') ||
				((*l_element_pile_systeme).type_cloture == 'F') ||
				((*l_element_pile_systeme).type_cloture == 'A'))
		{
			presence_boucle = d_vrai;
		}

		l_element_pile_systeme = (*l_element_pile_systeme).suivant;
	}

	if (presence_boucle == d_faux)
	{
		(*s_etat_processus).erreur_execution = d_ex_cycle_hors_boucle;
		return;
	}

	if ((*s_etat_processus).mode_execution_programme == 'Y')
	{
		drapeau_presence_fin_boucle = d_vrai;
		tampon = (*s_etat_processus).instruction_courante;
		niveau = 1;

		instruction_majuscule = conversion_majuscule(s_etat_processus, "");

		while(!(((strcmp(instruction_majuscule, "NEXT") == 0) ||
				(strcmp(instruction_majuscule, "STEP") == 0)) && (niveau == 0)))
		{
			free(instruction_majuscule);

			erreur = recherche_instruction_suivante(s_etat_processus);

			if (erreur == d_erreur)
			{
				return;
			}

			instruction_majuscule = conversion_majuscule(s_etat_processus,
					(*s_etat_processus).instruction_courante);

			if (instruction_majuscule == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			/*
			 * Traitement de la pile système par les
			 * différentes instructions.
			 */

			if ((strcmp(instruction_majuscule, "IF") == 0) ||
					(strcmp(instruction_majuscule, "IFERR") == 0) ||
					(strcmp(instruction_majuscule, "DO") == 0) ||
					(strcmp(instruction_majuscule, "WHILE") == 0) ||
					(strcmp(instruction_majuscule, "FOR") == 0) ||
					(strcmp(instruction_majuscule, "FORALL") == 0) ||
					(strcmp(instruction_majuscule, "START") == 0) ||
					(strcmp(instruction_majuscule, "SELECT") == 0)
					|| (strcmp(instruction_majuscule, "CRITICAL") == 0)
					|| (strcmp(instruction_majuscule, "CASE") == 0)
					|| (strcmp(instruction_majuscule, "<<") == 0))
			{
				if (strcmp(instruction_majuscule, "<<") == 0)
				{
					analyse(s_etat_processus, NULL);
				}
				else
				{
					if ((strcmp(instruction_majuscule, "FOR") == 0) ||
							(strcmp(instruction_majuscule, "FORALL") == 0) ||
							(strcmp(instruction_majuscule, "START") == 0))
					{
						niveau++;
					}

					empilement_pile_systeme(s_etat_processus);

					if ((*s_etat_processus).erreur_systeme != d_es)
					{
						return;
					}
				}
			}
			else if ((strcmp(instruction_majuscule, "END") == 0) ||
					(strcmp(instruction_majuscule, "NEXT") == 0) ||
					(strcmp(instruction_majuscule, "STEP") == 0) ||
					(strcmp(instruction_majuscule, ">>") == 0))
			{
				if (strcmp(instruction_majuscule, ">>") == 0)
				{
					analyse(s_etat_processus, NULL);

					if ((*s_etat_processus).retour_routine_evaluation
							== 'Y')
					{
						drapeau_presence_fin_boucle = d_faux;
						free((*s_etat_processus).instruction_courante);

						break;
					}
				}
				else
				{
					if ((strcmp(instruction_majuscule, "NEXT") == 0) ||
							(strcmp(instruction_majuscule, "STEP") == 0))
					{
						niveau--;

						if (niveau != 0)
						{
							depilement_pile_systeme(s_etat_processus);
						}
					}
					else
					{
						if ((*s_etat_processus).l_base_pile_systeme == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_processus;
							return;
						}

						if ((*(*s_etat_processus).l_base_pile_systeme)
								.type_cloture == 'Q')
						{
							if (pthread_mutex_unlock(
									&mutex_sections_critiques) != 0)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							(*s_etat_processus).sections_critiques--;
						}

						depilement_pile_systeme(s_etat_processus);
					}

					if ((*s_etat_processus).erreur_systeme != d_es)
					{
						return;
					}
				}
			}

			free((*s_etat_processus).instruction_courante);
		}

		free(instruction_majuscule);
		(*s_etat_processus).instruction_courante = tampon;

		if (drapeau_presence_fin_boucle == d_faux)
		{
			(*s_etat_processus).traitement_cycle_exit = 'C';
		}
		else
		{
			(*s_etat_processus).traitement_cycle_exit = 'N';
			(*s_etat_processus).position_courante -= 5;
		}
	}
	else
	{
		/* CYCLE apparaissant dans l'évaluation d'une expression */

		drapeau_presence_fin_boucle = d_faux;
		instruction_majuscule = NULL;
		niveau = 1;

		while((*s_etat_processus).expression_courante != NULL)
		{
			while((*(*(*s_etat_processus).expression_courante).donnee)
					.type != FCT)
			{
				if ((*s_etat_processus).expression_courante == NULL)
				{
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_traitement_boucle;
					return;
				}

				(*s_etat_processus).expression_courante = (*(*s_etat_processus)
						.expression_courante).suivant;
			}

			BUG((*(*(*s_etat_processus).expression_courante).donnee).type
					!= FCT, printf("Not a function\n"));

			fonction = (*((struct_fonction *) (*(*(*s_etat_processus)
					.expression_courante).donnee).objet)).fonction;

			if ((fonction == instruction_if) ||
					(fonction == instruction_iferr) ||
					(fonction == instruction_do) ||
					(fonction == instruction_while) ||
					(fonction == instruction_for) ||
					(fonction == instruction_forall) ||
					(fonction == instruction_start) ||
					(fonction == instruction_select) ||
					(fonction == instruction_case) ||
					(fonction == instruction_critical) ||
					(fonction == instruction_vers_niveau_superieur))
			{
				if (fonction == instruction_vers_niveau_superieur)
				{
					analyse(s_etat_processus,
							instruction_vers_niveau_superieur);
				}
				else
				{
					if ((fonction == instruction_for) ||
							(fonction == instruction_forall) ||
							(fonction == instruction_start))
					{
						niveau++;
					}

					empilement_pile_systeme(s_etat_processus);

					if ((*s_etat_processus).erreur_systeme != d_es)
					{
						return;
					}
				}
			}
			else if ((fonction == instruction_end) ||
					(fonction == instruction_next) ||
					(fonction == instruction_step) ||
					(fonction == instruction_vers_niveau_inferieur))
			{
				if (fonction == instruction_vers_niveau_inferieur)
				{
					analyse(s_etat_processus,
							instruction_vers_niveau_inferieur);
				}
				else
				{
					if ((fonction == instruction_next) ||
							(fonction == instruction_step))
					{
						niveau--;

						if (niveau != 0)
						{
							depilement_pile_systeme(s_etat_processus);
						}
						else
						{
							drapeau_presence_fin_boucle = d_vrai;
							break;
						}
					}
					else
					{
						if ((*s_etat_processus).l_base_pile_systeme == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_processus;
							return;
						}

						if ((*(*s_etat_processus).l_base_pile_systeme)
							   	.type_cloture == 'Q')
						{
							if (pthread_mutex_unlock(&mutex_sections_critiques)
									!= 0)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							(*s_etat_processus).sections_critiques--;
						}	

						depilement_pile_systeme(s_etat_processus);
					}

					if ((*s_etat_processus).erreur_systeme != d_es)
					{
						return;
					}
				}
			}

			(*s_etat_processus).expression_courante = (*(*s_etat_processus)
					.expression_courante).suivant;
		}

		if (drapeau_presence_fin_boucle == d_faux)
		{
			(*s_etat_processus).traitement_cycle_exit = 'C';
		}
		else
		{
			(*s_etat_processus).traitement_cycle_exit = 'N';

			if (fonction == instruction_next)
			{
				instruction_next(s_etat_processus);
			}
			else
			{
				instruction_step(s_etat_processus);
			}
		}
	}

	return;
}


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

void
instruction_con(struct_processus *s_etat_processus)
{
	struct_liste_chainee			*l_element_courant;

	struct_objet					*s_objet_1;
	struct_objet					*s_objet_2;
	struct_objet					*s_objet_resultat;

	logical1						argument_nom;
	logical1						variable_partagee;

	integer8						i;
	integer8						j;
	integer8						nombre_colonnes;
	integer8						nombre_dimensions;
	integer8						nombre_lignes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(matrice constante)\n\n");
		}
		else
		{
			printf("(constant matrix)\n\n");
		}

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

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

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

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

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

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

		printf("    2: %s\n", d_NOM);
		printf("    1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

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

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

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

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

	if ((*s_objet_2).type == NOM)
	{
		argument_nom = d_vrai;

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

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

			return;
		}

		liberation(s_etat_processus, s_objet_2);

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

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

		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
		{
			// Variable partagée

			variable_partagee = d_vrai;

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

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

				return;
			}

			s_objet_2 = (*(*s_etat_processus)
					.pointeur_variable_partagee_courante).objet;
		}
		else
		{
			// Variable privée

			s_objet_2 = (*(*s_etat_processus).pointeur_variable_courante).objet;
			variable_partagee = d_faux;
		}
	}
	else
	{
		argument_nom = d_faux;
		variable_partagee = d_faux;
	}
	
/*
--------------------------------------------------------------------------------
  Tableau créé à partir d'une spécification de dimension
--------------------------------------------------------------------------------
*/

	if ((*s_objet_2).type == LST)
	{
		l_element_courant = (*s_objet_2).objet;
		nombre_dimensions = 0;

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

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

			if (argument_nom == d_faux)
			{
				liberation(s_etat_processus, s_objet_2);
			}
			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;
					}
				}
			}

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

		nombre_colonnes = 0;
		nombre_lignes = 0;

		l_element_courant = (*s_objet_2).objet;

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

				if (argument_nom == d_faux)
				{
					liberation(s_etat_processus, s_objet_2);
				}
				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;
						}
					}
				}

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

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

				if (argument_nom == d_faux)
				{
					liberation(s_etat_processus, s_objet_2);
				}
				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;
						}
					}
				}

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

			if (nombre_lignes == 0)
			{
				nombre_lignes = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}
			else
			{
				nombre_colonnes = (*((integer8 *)
						(*(*l_element_courant).donnee).objet));
			}

			l_element_courant = (*l_element_courant).suivant;
		}
	}

/*
--------------------------------------------------------------------------------
  Tableau créé à partir des dimensions d'un autre tableau
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_2).type == VIN) ||
			((*s_objet_2).type == VRL) ||
			((*s_objet_2).type == VCX))
	{
		nombre_dimensions = 1;
		nombre_lignes = (*((struct_vecteur *) (*s_objet_2).objet)).taille;
		nombre_colonnes = 0;
	}
	else if (((*s_objet_2).type == MIN) ||
			((*s_objet_2).type == MRL) ||
			((*s_objet_2).type == MCX))
	{
		nombre_dimensions = 2;
		nombre_lignes = (*((struct_matrice *) (*s_objet_2).objet))
				.nombre_lignes;
		nombre_colonnes = (*((struct_matrice *) (*s_objet_2).objet))
				.nombre_colonnes;
	}

/*
--------------------------------------------------------------------------------
  Spécifications incorrectes
--------------------------------------------------------------------------------
*/

	else
	{
		if (argument_nom == d_faux)
		{
			liberation(s_etat_processus, s_objet_2);
		}
		else
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}

		liberation(s_etat_processus, s_objet_1);

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

/*
--------------------------------------------------------------------------------
  Création effective du tableau
--------------------------------------------------------------------------------
*/

	if (((*s_objet_1).type != INT) &&
			((*s_objet_1).type != REL) &&
			((*s_objet_1).type != CPL))
	{
		if (argument_nom == d_faux)
		{
			liberation(s_etat_processus, s_objet_2);
		}
		else
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}

		liberation(s_etat_processus, s_objet_1);

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

	if (nombre_dimensions == 1)
	{
		/*
		 * Vecteur
		 */

		if ((*s_objet_1).type == INT)
		{
			if ((s_objet_resultat = allocation(s_etat_processus, VIN))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
					nombre_lignes;

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) * sizeof(integer8)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
						.objet)).tableau)[i] = (*((integer8 *)
						(*s_objet_1).objet));
			}
		}
		else if ((*s_objet_1).type == REL)
		{
			if ((s_objet_resultat = allocation(s_etat_processus, VRL))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
					nombre_lignes;

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) * sizeof(real8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
						.objet)).tableau)[i] = (*((real8 *)
						(*s_objet_1).objet));
			}
		}
		else
		{
			if ((s_objet_resultat = allocation(s_etat_processus, VCX))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
					nombre_lignes;

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
						.objet)).tableau)[i].partie_reelle =
						(*((struct_complexe16 *)
						(*s_objet_1).objet)).partie_reelle;
				((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
						.objet)).tableau)[i].partie_imaginaire =
						(*((struct_complexe16 *)
						(*s_objet_1).objet)).partie_imaginaire;
			}
		}
	}
	else
	{
		/*
		 * Matrice
		 */

		if ((*s_objet_1).type == INT)
		{
			if ((s_objet_resultat = allocation(s_etat_processus, MIN))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					nombre_colonnes;

			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) * sizeof(integer8 *)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
						.objet)).tableau)[i] = malloc(((size_t)
						nombre_colonnes) * sizeof(integer8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				for(j = 0; j < nombre_colonnes; j++)
				{
					((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = (*((integer8 *)
							(*s_objet_1).objet));
				}
			}
		}
		else if ((*s_objet_1).type == REL)
		{
			if ((s_objet_resultat = allocation(s_etat_processus, MRL))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					nombre_colonnes;

			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) * sizeof(real8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
						.objet)).tableau)[i] = malloc(((size_t)
						nombre_colonnes) * sizeof(real8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				for(j = 0; j < nombre_colonnes; j++)
				{
					((real8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = (*((real8 *)
							(*s_objet_1).objet));
				}
			}
		}
		else
		{
			if ((s_objet_resultat = allocation(s_etat_processus, MCX))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					nombre_colonnes;

			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
					malloc(((size_t) nombre_lignes) *
					sizeof(struct_complexe16 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < nombre_lignes; i++)
			{
				if ((((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i] =
						malloc(((size_t) nombre_colonnes) *
						sizeof(struct_complexe16))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				for(j = 0; j < nombre_colonnes; j++)
				{
					((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]
							.partie_reelle = (*((struct_complexe16 *)
							(*s_objet_1).objet)).partie_reelle;
					((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]
							.partie_imaginaire = (*((struct_complexe16 *)
							(*s_objet_1).objet)).partie_imaginaire;
				}
			}
		}
	}

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

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

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

	return;
}


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

void
instruction_cross(struct_processus *s_etat_processus)
{
	integer8						tampon_1;
	integer8						tampon_2;

	logical1						depassement;

	struct_complexe16				registre_a;
	struct_complexe16				registre_b;

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

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(produit vectoriel)\n\n");
		}
		else
		{
			printf("(product of vectors)\n\n");
		}

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

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

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

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

/*
--------------------------------------------------------------------------------
  Résultat entier
--------------------------------------------------------------------------------
*/

	if (((*s_objet_argument_1).type == VIN) &&
			((*s_objet_argument_2).type == VIN))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(integer8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		depassement = depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[1]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &(tampon_1));

		depassement |= depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[2]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &(tampon_2));

		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
				.objet)).tableau)[0]));

		depassement |= depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[2]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &(tampon_1));

		depassement |= depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[0]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &(tampon_2));

		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
				.objet)).tableau)[1]));

		depassement |= depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[0]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &(tampon_1));

		depassement |= depassement_multiplication(&(((integer8 *)
				(*((struct_vecteur *) (*s_objet_argument_2).objet))
				.tableau)[1]), &(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &(tampon_2));

		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
				.objet)).tableau)[2]));

		if (depassement != d_absence_erreur)
		{
			(*s_objet_resultat).type = VRL;
			(*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R';
			free((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau);

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					malloc(3 * sizeof(real8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
					.tableau)[0] = ((real8) ((integer8 *) (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).tableau)[1] * (real8)
					((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
					.objet)).tableau)[2]) - ((real8) ((integer8 *)
					(*((struct_vecteur *) (*s_objet_argument_2).objet))
					.tableau)[2] * (real8) ((integer8 *) (*((struct_vecteur *)
					(*s_objet_argument_1).objet)).tableau)[1]);
			((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
					.tableau)[1] = ((real8) ((integer8 *) (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).tableau)[2] * (real8)
					((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
					.objet)).tableau)[0]) - ((real8) ((integer8 *)
					(*((struct_vecteur *) (*s_objet_argument_2).objet))
					.tableau)[0] * (real8) ((integer8 *) (*((struct_vecteur *)
					(*s_objet_argument_1).objet)).tableau)[2]);
			((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
					.tableau)[2] = ((real8) ((integer8 *) (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).tableau)[0] * (real8)
					((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
					.objet)).tableau)[1]) - ((real8) ((integer8 *)
					(*((struct_vecteur *) (*s_objet_argument_2)
					.objet)).tableau)[1] * (real8) ((integer8 *)
					(*((struct_vecteur *) (*s_objet_argument_1).objet))
					.tableau)[0]);
		}
	}

/*
--------------------------------------------------------------------------------
  Résultat réel
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_argument_1).type == VRL) &&
			((*s_objet_argument_2).type == VIN))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[0] = ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])
				- ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2] *
				((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[1] = ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])
				- ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2) .objet)).tableau)[0] *
				((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[2] = ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])
				- ((real8) ((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1] *
				((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]);
	}
	else if (((*s_objet_argument_1).type == VIN) &&
			((*s_objet_argument_2).type == VRL))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[0] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1] * (real8)
				((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2])
				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
				.objet)).tableau)[2] * (real8) ((integer8 *)
				(*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[1] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2] * (real8)
				((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
				.objet)).tableau)[0]) - (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2) .objet)).tableau)[0] * (real8)
				((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[2] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0] * (real8)
				((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
				.objet)).tableau)[1]) - (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2) .objet)).tableau)[1] * (real8)
				((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]);
	}
	else if (((*s_objet_argument_1).type == VRL) &&
			((*s_objet_argument_2).type == VRL))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[0] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])
				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
				.objet)).tableau)[2] * ((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[1] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])
				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
				.objet)).tableau)[0] * ((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]);
		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
				.tableau)[2] = (((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0] * ((real8 *)
				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])
				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
				.objet)).tableau)[1] * ((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]);
	}

/*
--------------------------------------------------------------------------------
  Résultat complexe
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_argument_1).type == VIN) &&
			((*s_objet_argument_2).type == VCX))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_a);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[0]));

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_a);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[1]));

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_a);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[2]));
	}
	else if (((*s_objet_argument_1).type == VRL) &&
			((*s_objet_argument_2).type == VCX))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_a);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[0]));

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_a);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[1]));

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_a);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[2]));
	}
	else if (((*s_objet_argument_1).type == VCX) &&
			((*s_objet_argument_2).type == VCX))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_a);
		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[0]));

		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_a);
		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[1]));

		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]), &registre_a);
		f77multiplicationcc_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]),
				&(((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]), &registre_b);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[2]));
	}
	else if (((*s_objet_argument_2).type == VRL) &&
			((*s_objet_argument_1).type == VCX))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]), &registre_b);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[0]));

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]), &registre_b);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[1]));

		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]), &registre_b);
		f77multiplicationcr_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]),
				&(((real8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[2]));
	}
	else if (((*s_objet_argument_2).type == VIN) &&
			((*s_objet_argument_1).type == VCX))
	{
		if (((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille != 3)
				|| ((*((struct_vecteur *)  (*s_objet_argument_1).objet)).taille
				!= 3))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille = 3;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc(3 * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]), &registre_b);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[0]));

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[2]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]), &registre_b);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[2]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[1]));

		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[0]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[1]), &registre_b);
		f77multiplicationci_((&((struct_complexe16 *) (*((struct_vecteur *)
				(*s_objet_argument_1).objet)).tableau)[1]),
				&(((integer8 *) (*((struct_vecteur *)
				(*s_objet_argument_2).objet)).tableau)[0]), &registre_a);
		f77soustractioncc_(&registre_a, &registre_b, &(((struct_complexe16 *)
				(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[2]));
	}

/*
--------------------------------------------------------------------------------
  Types incompatibles avec la fonction CROSS
--------------------------------------------------------------------------------
*/

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

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

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

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

	return;
}

// vim: ts=4