/*
================================================================================
  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 'trn'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_trn(struct_processus *s_etat_processus)
{
	struct_objet						*s_objet_argument;
	struct_objet						*s_objet_resultat;

	logical1							argument_nom;
	logical1							variable_partagee;

	integer8							i;
	integer8							j;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(transposition)\n\n");
		}
		else
		{
			printf("(transposition)\n\n");
		}

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

		printf("    1: %s\n", d_NOM);

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

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

	variable_partagee = d_faux;

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

		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument).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);

			return;
		}

		liberation(s_etat_processus, s_objet_argument);

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

		if ((*(*s_etat_processus).pointeur_variable_courante).objet != NULL)
		{
			s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
					.objet;
		}
		else
		{
			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);

				return;
			}

			variable_partagee = d_vrai;
		}
	}
	else
	{
		argument_nom = d_faux;
	}

/*
--------------------------------------------------------------------------------
  Matrice transposée d'une matrice entière
--------------------------------------------------------------------------------
 */

	if ((*s_objet_argument).type == MIN)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

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

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

/*
--------------------------------------------------------------------------------
  Matrice tranposée d'une matrice réelle
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == MRL)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

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

		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 ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
					.objet)).tableau)[i] = malloc(((size_t)
					(*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes) * sizeof(real8))) == NULL)
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

/*
--------------------------------------------------------------------------------
  Matrice transposée (et conjuguée) d'une matrice complexe
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == MCX)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

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

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
				.objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == 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_complexe16 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc(((size_t) (*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes) *
					sizeof(struct_complexe16))) == NULL)
			{
				if (variable_partagee == d_vrai)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.pointeur_variable_partagee_courante).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

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

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

/*
--------------------------------------------------------------------------------
  Fonction transposée impossible à réaliser
--------------------------------------------------------------------------------
*/

	else
	{
		if (argument_nom == d_faux)
		{
			liberation(s_etat_processus, s_objet_argument);
		}

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

	liberation(s_etat_processus, s_objet_argument);

	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 'tot'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_tot(struct_processus *s_etat_processus)
{
	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;
	struct_objet						*s_objet_temporaire;

	integer8							nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme des colonnes statistiques)\n\n");
		}
		else
		{
			printf("(sum of statistical columns)\n\n");
		}

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

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

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

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

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

		(*s_etat_processus).erreur_systeme = d_es;

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

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

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

	if (nombre_colonnes == 0)
	{
		(*s_etat_processus).erreur_execution =
				d_ex_matrice_statistique_invalide;
		return;
	}

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

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*s_objet_resultat).objet = sommation_statistique(
				s_etat_processus,
				(struct_matrice *) (*s_objet_statistique).objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (nombre_colonnes == 1)
		{
			if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
			{
				(*s_objet_resultat).type = VIN;
				s_objet_temporaire = s_objet_resultat;

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

				(*((integer8 *) (*s_objet_resultat).objet)) =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_temporaire).objet)).tableau)[0];

				liberation(s_etat_processus, s_objet_temporaire);
			}
			else
			{
				(*s_objet_resultat).type = VRL;
				s_objet_temporaire = s_objet_resultat;

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

				(*((real8 *) (*s_objet_resultat).objet)) =
						((real8 *) (*((struct_vecteur *)
						(*s_objet_temporaire).objet)).tableau)[0];

				liberation(s_etat_processus, s_objet_temporaire);
			}
		}
		else
		{
			if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
			{
				(*s_objet_resultat).type = VIN;
			}
			else
			{
				(*s_objet_resultat).type = VRL;
			}
		}

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

	return;
}


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

void
instruction_title(struct_processus *s_etat_processus)
{
	struct_objet					*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(titre d'un graphique)\n\n");
		}
		else
		{
			printf("(title of graphic)\n\n");
		}

		printf("    1: %s\n", d_CHN);

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

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

	if ((*s_objet).type == CHN)
	{
		free((*s_etat_processus).titre);

		if (((*s_etat_processus).titre = malloc((strlen((unsigned char *)
				(*s_objet).objet) + 1) * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*s_etat_processus).titre, (unsigned char *) (*s_objet).objet);
		liberation(s_etat_processus, s_objet);
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

	if (test_cfsf(s_etat_processus, 52) == d_faux)
	{
		if ((*s_etat_processus).fichiers_graphiques != NULL)
		{
			appel_gnuplot(s_etat_processus, 'N');
		}
	}

	return;
}


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

void
instruction_time(struct_processus *s_etat_processus)
{
	struct rusage			s_usage_processus_fils;
	struct rusage			s_usage_processus_pere;

	struct_liste_chainee	*l_element_courant;

	struct_objet			*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(temps CPU)\n\n");
		}
		else
		{
			printf("(CPU time)\n\n");
		}

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

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

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

	/*
	 * Lecture des différents temps
	 */

#	ifndef OS2
	if ((getrusage(RUSAGE_SELF, &s_usage_processus_pere)) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if ((getrusage(RUSAGE_CHILDREN, &s_usage_processus_fils)) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}
#	else
	s_usage_processus_pere.ru_utime.tv_sec = 0;
	s_usage_processus_pere.ru_utime.tv_usec = 0;
	s_usage_processus_pere.ru_stime.tv_sec = 0;
	s_usage_processus_pere.ru_stime.tv_usec = 0;
	s_usage_processus_fils.ru_utime.tv_sec = 0;
	s_usage_processus_fils.ru_utime.tv_usec = 0;
	s_usage_processus_fils.ru_stime.tv_sec = 0;
	s_usage_processus_fils.ru_stime.tv_usec = 0;
#	endif

	/*
	 * Initialisation de la liste
	 */

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

	/*
	 * User time du processus père (séquenceur)
	 */

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

	(*s_objet).objet = l_element_courant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*l_element_courant).donnee).objet)) =
			((real8) s_usage_processus_pere.ru_utime.tv_sec) +
			(((real8) s_usage_processus_pere.ru_utime.tv_usec) /
			((real8) 1E6));

	/*
	 * System time du processus père
	 */

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*l_element_courant).donnee).objet)) =
			((real8) s_usage_processus_pere.ru_stime.tv_sec) +
			(((real8) s_usage_processus_pere.ru_stime.tv_usec) /
			((real8) 1E6));

	/*
	 * User time des processus fils achevés
	 */

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*l_element_courant).donnee).objet)) =
			((real8) s_usage_processus_fils.ru_utime.tv_sec) +
			(((real8) s_usage_processus_fils.ru_utime.tv_usec) /
			((real8) 1E6));

	/*
	 * System time des processus fils achevés
	 */

	if (((*l_element_courant).suivant =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*l_element_courant).donnee).objet)) =
			((real8) s_usage_processus_fils.ru_stime.tv_sec) +
			(((real8) s_usage_processus_fils.ru_stime.tv_usec) /
			((real8) 1E6));

	/*
	 * Fermeture de la liste
	 */

	(*l_element_courant).suivant = NULL;

	/*
	 * Empilement du résultat
	 */

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

	return;
}


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

void
instruction_taylr(struct_processus *s_etat_processus)
{
	integer8					i;

	logical1					last_valide;
	logical1					zero;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_argument_3;
	struct_objet				*s_objet_argument_4;
	struct_objet				*s_objet_resultat;
	struct_objet				*s_objet_variable_derivation;

	struct_variable				s_variable;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(série de Taylor)\n\n");
		}
		else
		{
			printf("(Taylor serie)\n\n");
		}

		printf("    4: %s\n", d_ALG);
		printf("    3: %s\n", d_NOM);
		printf("    2: %s, %s\n", d_INT, d_REL);
		printf("    1: %s\n", d_INT);
		printf("->  1: %s\n\n", d_ALG);

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

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

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

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

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

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

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

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

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

	if (((*s_objet_argument_4).type == ALG) &&
			((*s_objet_argument_3).type == NOM) &&
			(((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL)) &&
			((*s_objet_argument_1).type == INT))
	{
		if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);

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

		if ((*s_objet_argument_2).type == REL)
		{
			if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
			{
				zero = d_vrai;
			}
			else
			{
				zero = d_faux;
			}
		}
		else
		{
			if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
			{
				zero = d_vrai;
			}
			else
			{
				zero = d_faux;
			}
		}

		/*
		 * Conversion du drapeau symbole des variables symboliques
		 */

		l_element_courant = (*s_objet_argument_4).objet;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type == NOM)
			{
				if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee)
						.objet)).nom, (*((struct_nom *) (*s_objet_argument_3)
						.objet)).nom) == 0)
				{
					(*((struct_nom *) (*(*l_element_courant).donnee).objet))
							.symbole = d_faux;
				}
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		/*
		 * Création de la variable locale et initialisation
		 */

		(*s_etat_processus).niveau_courant++;

		if ((s_variable.nom = malloc((strlen((*((struct_nom *)
				(*s_objet_argument_3).objet)).nom) + 1) *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_variable.niveau = (*s_etat_processus).niveau_courant;
		strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_argument_3)
				.objet)).nom);

		if ((s_variable.objet = copie_objet(s_etat_processus,
				s_objet_argument_2, 'O')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
				== d_erreur)
		{
			return;
		}

		/*
		 * Création de la série
		 */

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

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

		l_element_courant = (*s_objet_resultat).objet;

		if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_superieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, "<<");

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

		/*
		 * Calcul de la série de Taylor
		 *
		 * s(x) = \sum_{i=0}{n} (1/i!)*((d^i f(x=a))/d(x^i)*(x-a)^i)
		 */

		for(i = 0; (i <= (*((integer8 *) (*s_objet_argument_1).objet))) &&
				((*s_etat_processus).var_volatile_requete_arret == 0); i++)
		{
			/*
			 * Calcul de ((d^i f(x=a))/d(x^i)*(x-a)^i)/i!
			 */

			if (i != 0)
			{
				// Calcul de la valeur de la dérivée n-ième
				// Expression empilée puis dérivée et sauvegardée dans
				// s_argument_4.

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

					return;
				}

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

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

					return;
				}

				instruction_der(s_etat_processus);

				if ((*s_etat_processus).erreur_execution != d_ex)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);
					liberation(s_etat_processus, s_objet_argument_3);

					(*l_element_courant).suivant = NULL;

					liberation(s_etat_processus, s_objet_resultat);

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

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

				if ((*s_etat_processus).var_volatile_requete_arret != 0)
				{
					/*
					 * instruction_der() n'a rien renvoyé dans la pile. On
					 * injecte une valeur nulle dans s_objet_argument_4.
					 */

					if ((s_objet_argument_4 = allocation(s_etat_processus,
							INT)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}
				}
				else if (depilement(s_etat_processus, &((*s_etat_processus)
						.l_base_pile), &s_objet_argument_4) == d_erreur)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);
					liberation(s_etat_processus, s_objet_argument_3);

					(*l_element_courant).suivant = NULL;

					liberation(s_etat_processus, s_objet_resultat);

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

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

			if (evaluation(s_etat_processus, s_objet_argument_4, 'E')
					== d_erreur)
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_argument_3);
				liberation(s_etat_processus, s_objet_argument_4);

				(*l_element_courant).suivant = NULL;

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

				return;
			}

			// Division par i!

			if (i > 1)
			{

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

				(*((integer8 *) (*s_objet_argument).objet)) = i;

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

					(*l_element_courant).suivant = NULL;

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

					return;
				}

				if (i > 2)
				{
					instruction_fact(s_etat_processus);

					if ((*s_etat_processus).erreur_execution != d_ex)
					{
						liberation(s_etat_processus, s_objet_argument_1);
						liberation(s_etat_processus, s_objet_argument_2);
						liberation(s_etat_processus, s_objet_argument_3);
						liberation(s_etat_processus, s_objet_argument_4);

						(*l_element_courant).suivant = NULL;

						liberation(s_etat_processus, s_objet_resultat);

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

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

				instruction_division(s_etat_processus);

				if ((*s_etat_processus).erreur_execution != d_ex)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);
					liberation(s_etat_processus, s_objet_argument_3);
					liberation(s_etat_processus, s_objet_argument_4);

					(*l_element_courant).suivant = NULL;

					liberation(s_etat_processus, s_objet_resultat);

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

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

			if (((*l_element_courant).suivant =
					allocation_maillon(s_etat_processus)) == NULL)
			{
				(*s_etat_processus).erreur_systeme =
						d_es_allocation_memoire;
				return;
			}

			l_element_courant = (*l_element_courant).suivant;

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

				(*l_element_courant).donnee = NULL;
				(*l_element_courant).suivant = NULL;

				liberation(s_etat_processus, s_objet_resultat);

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

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

			/*
			 * Multiplication par le terme (x-a)**i
			 */

			if (i != 0)
			{
				if (((*l_element_courant).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_courant = (*l_element_courant).suivant;

				if (((*l_element_courant).donnee =
						copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (zero == d_faux)
				{
					if (((*l_element_courant).suivant =
							allocation_maillon(s_etat_processus)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					l_element_courant = (*l_element_courant).suivant;

					if (((*l_element_courant).donnee =
							copie_objet(s_etat_processus, s_objet_argument_2,
							'O')) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					if (((*l_element_courant).suivant =
							allocation_maillon(s_etat_processus)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					l_element_courant = (*l_element_courant).suivant;

					if (((*l_element_courant).donnee =
								allocation(s_etat_processus, FCT)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					(*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nombre_arguments = 0;
					(*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).fonction = instruction_moins;

					if (((*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nom_fonction = malloc(2 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nom_fonction, "-");
				}

				if (i > 1)
				{
					if (((*l_element_courant).suivant =
							allocation_maillon(s_etat_processus)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					l_element_courant = (*l_element_courant).suivant;

					if (((*l_element_courant).donnee =
							allocation(s_etat_processus, INT)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

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

					if (((*l_element_courant).suivant =
							allocation_maillon(s_etat_processus)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					l_element_courant = (*l_element_courant).suivant;

					if (((*l_element_courant).donnee =
							allocation(s_etat_processus, FCT)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					(*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nombre_arguments = 0;
					(*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).fonction = instruction_puissance;

					if (((*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nom_fonction = malloc(2 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
							.objet)).nom_fonction, "^");
				}

				if (((*l_element_courant).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_courant = (*l_element_courant).suivant;

				if (((*l_element_courant).donnee = allocation(s_etat_processus,
						FCT)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
						.nombre_arguments = 0;
				(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
						.fonction = instruction_multiplication;

				if (((*((struct_fonction *) (*(*l_element_courant).donnee)
						.objet)).nom_fonction = malloc(2 *
						sizeof(unsigned char))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
						.objet)).nom_fonction, "*");

				if (((*l_element_courant).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_courant = (*l_element_courant).suivant;

				if (((*l_element_courant).donnee = allocation(s_etat_processus,
						FCT)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
						.nombre_arguments = 0;
				(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
						.fonction = instruction_plus;

				if (((*((struct_fonction *) (*(*l_element_courant).donnee)
						.objet)).nom_fonction = malloc(2 *
						sizeof(unsigned char))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
						.objet)).nom_fonction, "+");
			}
		}

		/*
		 * Fermeture de l'expression
		 */

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

		if (((*l_element_courant).suivant =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_courant = (*l_element_courant).suivant;

		if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_inferieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, ">>");

		(*l_element_courant).suivant = NULL;

		/*
		 * Destruction de la variable locale
		 */

		(*s_etat_processus).niveau_courant--;

		if (retrait_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument_3).objet)).nom, 'L') == d_erreur)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_argument_3);
			liberation(s_etat_processus, s_objet_argument_4);
			liberation(s_etat_processus, s_objet_resultat);

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

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

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

	return;
}


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

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

	struct addrinfo				*resolution;
	struct addrinfo				*resolution_courante;

	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;

	unsigned long				i;
	unsigned long				nombre_elements;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(cible d'une socket non connectée)\n\n");
		}
		else
		{
			printf("(target of unconnected socket)\n\n");
		}

		printf("    2: %s, %s\n", d_CHN, d_LST);
		printf("    1: %s\n", d_SCK);
		printf("->  1: %s\n", d_SCK);

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

	if ((*s_objet_argument_1).type == SCK)
	{

		/*
		 * Vérification du type de socket
		 */

		if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
				"STREAM") == 0) || (strcmp((*((struct_socket *)
				(*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
				== 0))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*s_objet_argument_2).type == CHN)
		{
			/*
			 * La socket ne peut être que du domaine UNIX
			 */

			if ((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
					!= PF_UNIX)
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);

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

			free((*((struct_socket *) (*s_objet_argument_1).objet))
					.adresse_distante);

			if (((*((struct_socket *) (*s_objet_argument_1).objet))
					.adresse_distante = transliteration(s_etat_processus,
					(unsigned char *) (*s_objet_argument_2).objet,
					d_locale, "UTF-8")) == NULL)
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);

				return;
			}
		}
		else if ((*s_objet_argument_2).type == LST)
		{
			l_element_courant = (struct_liste_chainee *)
					(*s_objet_argument_2).objet;
			nombre_elements = 0;

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

			if (nombre_elements != 2)
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);

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

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

			if ((*(*l_element_courant).donnee).type == VIN)
			{
				if ((*((struct_vecteur *) (*(*l_element_courant).donnee).objet))
						.taille == 4)
				{
					if ((*((struct_socket *) (*s_objet_argument_1).objet))
							.domaine != PF_INET)
					{
						liberation(s_etat_processus, s_objet_argument_1);
						liberation(s_etat_processus, s_objet_argument_2);

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

					free((*((struct_socket *) (*s_objet_argument_1).objet))
							.adresse_distante);

					if (((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante = malloc(23 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					for(i = 0; i < 4; i++)
					{
						if ((((integer8 *) (*((struct_vecteur *)
								(*(*l_element_courant).donnee).objet)).tableau)
								[i] >= 0) && (((integer8 *)
								(*((struct_vecteur *) (*(*l_element_courant)
								.donnee).objet)).tableau)[i] <= 255))
						{
						}
						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_parametre_fichier;
							return;
						}
					}

					sprintf((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante, "%d.%d.%d.%d",
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[0],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[1],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[2],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[3]);
				}
				else if ((*((struct_vecteur *) (*(*l_element_courant).donnee)
						.objet)).taille == 16)
				{
					if ((*((struct_socket *) (*s_objet_argument_1).objet))
							.domaine != PF_INET6)
					{
						liberation(s_etat_processus, s_objet_argument_1);
						liberation(s_etat_processus, s_objet_argument_2);

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

					free((*((struct_socket *) (*s_objet_argument_1).objet))
							.adresse_distante);

					if (((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante = malloc(47 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					for(i = 0; i < 16; i++)
					{
						if ((((integer8 *) (*((struct_vecteur *)
								(*(*l_element_courant).donnee).objet)).tableau)
								[i] >= 0) && (((integer8 *)
								(*((struct_vecteur *) (*(*l_element_courant)
								.donnee).objet)).tableau)[i] <= 255))
						{
						}
						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_parametre_fichier;
							return;
						}
					}

					sprintf((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante,
							"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
							"%02X%02X:%02X%02X:%02X%02X:%02X%02X",
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[0],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[1],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[2],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[3],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[4],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[5],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[6],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[7],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[8],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[9],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[10],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[11],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[12],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[13],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[14],
							(int) ((integer8 *) (*((struct_vecteur *)
							(*(*l_element_courant).donnee).objet))
							.tableau)[15]);
				}
				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_parametre_fichier;
					return;
				}
			}
			else if ((*(*l_element_courant).donnee).type == CHN)
			{
				resolution = NULL;

				if (getaddrinfo((unsigned char *) (*(*l_element_courant)
						.donnee).objet, NULL, NULL, &resolution) != 0)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);

					if (resolution != NULL)
					{
						freeaddrinfo(resolution);
					}

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

				if ((*((struct_socket *) (*s_objet_argument_1).objet))
						.domaine == PF_INET)
				{ // Résolution du nom en IPv4
					resolution_courante = resolution;

					while(resolution_courante != NULL)
					{
						if ((*resolution_courante).ai_family == AF_INET)
						{
							break;
						}

						resolution_courante = (*resolution_courante).ai_next;
					}

					if (resolution_courante == NULL)
					{
						liberation(s_etat_processus, s_objet_argument_1);
						liberation(s_etat_processus, s_objet_argument_2);

						freeaddrinfo(resolution);

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

					free((*((struct_socket *) (*s_objet_argument_1).objet))
							.adresse_distante);

					if (((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante = malloc(23 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					sprintf((*((struct_socket *) (*s_objet_argument_1).objet))
							.adresse_distante, "%d.%d.%d.%d",
							(ntohl((*((struct sockaddr_in *)
							(*resolution_courante).ai_addr)).sin_addr.s_addr)
							>> 24) & 0xFF,
							(ntohl((*((struct sockaddr_in *)
							(*resolution_courante).ai_addr)).sin_addr.s_addr)
							>> 16) & 0xFF,
							(ntohl((*((struct sockaddr_in *)
							(*resolution_courante).ai_addr)).sin_addr.s_addr)
							>> 8) & 0xFF,
							ntohl((*((struct sockaddr_in *)
							(*resolution_courante).ai_addr)).sin_addr.s_addr)
							& 0xFF);
				}
				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
						.domaine == PF_INET6)
				{ // Résolution du nom en IPv6
#					ifdef IPV6
					resolution_courante = resolution;

					while(resolution_courante != NULL)
					{
						if ((*resolution_courante).ai_family == AF_INET6)
						{
							break;
						}

						resolution_courante = (*resolution_courante).ai_next;
					}

					if (resolution_courante == NULL)
					{
						liberation(s_etat_processus, s_objet_argument_1);
						liberation(s_etat_processus, s_objet_argument_2);

						freeaddrinfo(resolution);

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

					if (((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante = malloc(47 *
							sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					sprintf((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante,
							"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
							"%02X%02X:%02X%02X:%02X%02X:%02X%02X",
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[0],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[1],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[2],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[3],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[4],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[5],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[6],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[7],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[8],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[9],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[10],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[11],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[12],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[13],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[14],
							(*((struct sockaddr_in6 *) (*resolution_courante)
							.ai_addr)).sin6_addr.s6_addr[15]);
#					else
					if ((*s_etat_processus).langue == 'F')
					{
						printf("+++Attention : Support du protocole"
								" IPv6 indisponible\n");
					}
					else
					{
						printf("+++Warning : IPv6 support "
								"unavailable\n");
					}
#					endif
				}
				else
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);

					freeaddrinfo(resolution);

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

				freeaddrinfo(resolution);
			}
			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_parametre_fichier;
				return;
			}

			l_element_courant = (*l_element_courant).suivant;

			if ((*(*l_element_courant).donnee).type == INT)
			{
				if (((*((integer8 *) (*(*l_element_courant).donnee).objet))
						>= 0) && ((*((integer8 *) (*(*l_element_courant)
						.donnee).objet)) <= 65535))
				{
					sprintf((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante +
							strlen((*((struct_socket *) (*s_objet_argument_1)
							.objet)).adresse_distante), "(%u)", (unsigned int)
							(*((integer8 *) (*(*l_element_courant).donnee)
							.objet)));
				}
				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_parametre_fichier;
					return;
				}
			}
			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_parametre_fichier;
				return;
			}
		}
		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;
		}
	}
	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_2);

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

	return;
}


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

void
instruction_tail(struct_processus *s_etat_processus)
{
	integer8								longueur;

	struct_liste_chainee					*l_element_courant;

	struct_objet							*s_objet_argument;
	struct_objet							*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(remplace une liste par tous ses éléments hormis "
					"son premier)\n\n");
		}
		else
		{
			printf("(replace a list by all but its first element)\n\n");
		}

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

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

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

	if ((*s_objet_argument).type == LST)
	{
		l_element_courant = (*s_objet_argument).objet;
		longueur = 0;

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

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

			(*s_objet_resultat).objet = NULL;
		}
		else
		{
			if ((s_objet_resultat = copie_objet(s_etat_processus,
					s_objet_argument, 'N')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			l_element_courant = (*s_objet_resultat).objet;

			(*s_objet_resultat).objet = (*((struct_liste_chainee *)
					(*s_objet_resultat).objet)).suivant;

			liberation(s_etat_processus, (*l_element_courant).donnee);
			free(l_element_courant);
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

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

	liberation(s_etat_processus, s_objet_argument);

	return;
}

// vim: ts=4