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

void
instruction_dft(struct_processus *s_etat_processus)
{
	integer4					erreur;
	integer4					inverse;
	integer4					longueur_dft;
	integer4					nombre_colonnes;
	integer4					nombre_lignes;

	logical1					presence_longueur_dft;

	integer8					longueur_dft_signee;

	struct_complexe16			*matrice_f77;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_longueur_dft;
	struct_objet				*s_objet_resultat;

	integer8					i;
	integer8					j;
	integer8					k;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(transformée de Fourier discrète)\n\n");
		}
		else
		{
			printf("(discrete Fourier transform)\n\n");
		}

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

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

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

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

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

	/*
	 * Il est possible d'imposer une longueur de DFT au premier niveau
	 * de la pile.
	 */

	if ((*s_etat_processus).l_base_pile == NULL)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*(*(*s_etat_processus).l_base_pile).donnee).type == INT)
	{
		presence_longueur_dft = d_vrai;

		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_longueur_dft) == d_erreur)
		{
			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
			return;
		}

		longueur_dft_signee = (*((integer8 *) (*s_objet_longueur_dft).objet));

		liberation(s_etat_processus, s_objet_longueur_dft);

		if (longueur_dft_signee <= 0)
		{
			(*s_etat_processus).erreur_execution = d_ex_longueur_dft;
			return;
		}

		longueur_dft = (integer4) longueur_dft_signee;
	}
	else
	{
		presence_longueur_dft = d_faux;
		longueur_dft = 0;

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

/*
--------------------------------------------------------------------------------
  Vecteur
--------------------------------------------------------------------------------
*/

	if (((*s_objet_argument).type == VIN) ||
			((*s_objet_argument).type == VRL) ||
			((*s_objet_argument).type == VCX))
	{
		if (presence_longueur_dft == d_faux)
		{
			longueur_dft = (integer4) (*((struct_vecteur *)
					(*s_objet_argument).objet)).taille;
		}

		if ((matrice_f77 = malloc(((size_t) longueur_dft) *
				sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_objet_argument).type == VIN)
		{
			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
					.taille; i++)
			{
				matrice_f77[i].partie_reelle = (real8) ((integer8 *)
						(*((struct_vecteur *) (*s_objet_argument).objet))
						.tableau)[i];
				matrice_f77[i].partie_imaginaire = (real8) 0;
			}
		}
		else if ((*s_objet_argument).type == VRL)
		{
			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
					.taille; i++)
			{
				matrice_f77[i].partie_reelle = ((real8 *)
						(*((struct_vecteur *) (*s_objet_argument).objet))
						.tableau)[i];
				matrice_f77[i].partie_imaginaire = (real8) 0;
			}
		}
		else
		{
			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
					.taille; i++)
			{
				matrice_f77[i].partie_reelle = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument).objet))
						.tableau)[i].partie_reelle;
				matrice_f77[i].partie_imaginaire = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument).objet))
						.tableau)[i].partie_imaginaire;
			}
		}

		for(; i < longueur_dft; i++)
		{
				matrice_f77[i].partie_reelle = (real8) 0;
				matrice_f77[i].partie_imaginaire = (real8) 0;
		}

		nombre_lignes = 1;
		nombre_colonnes = longueur_dft;
		inverse = 0;

		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);

		if (erreur != 0)
		{
			liberation(s_etat_processus, s_objet_argument);
			free(matrice_f77);

			(*s_etat_processus).erreur_execution = d_ex_longueur_dft;
			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 = longueur_dft;
		(*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = matrice_f77;
	}

/*
--------------------------------------------------------------------------------
  Matrice
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_argument).type == MIN) ||
			((*s_objet_argument).type == MRL) ||
			((*s_objet_argument).type == MCX))
	{
		if (presence_longueur_dft == d_faux)
		{
			longueur_dft = (integer4) (*((struct_matrice *)
					(*s_objet_argument).objet)).nombre_colonnes;
		}

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

		if ((*s_objet_argument).type == MIN)
		{
			for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; j++)
			{
				for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
						.objet)).nombre_colonnes; i++)
				{
					matrice_f77[k].partie_reelle = (real8) ((integer8 **)
							(*((struct_matrice *) (*s_objet_argument).objet))
							.tableau)[j][i];
					matrice_f77[k++].partie_imaginaire = (real8) 0;
				}
			}

			for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; k++)
			{
				matrice_f77[k].partie_reelle = (real8) 0;
				matrice_f77[k].partie_imaginaire = (real8) 0;
			}
		}
		else if ((*s_objet_argument).type == MRL)
		{
			for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; j++)
			{
				for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
						.objet)).nombre_colonnes; i++)
				{
					matrice_f77[k].partie_reelle = ((real8 **)
							(*((struct_matrice *) (*s_objet_argument).objet))
							.tableau)[j][i];
					matrice_f77[k++].partie_imaginaire = (real8) 0;
				}
			}

			for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; k++)
			{
				matrice_f77[k].partie_reelle = (real8) 0;
				matrice_f77[k].partie_imaginaire = (real8) 0;
			}
		}
		else
		{
			for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; j++)
			{
				for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
						.objet)).nombre_colonnes; i++)
				{
					matrice_f77[k].partie_reelle = ((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument).objet))
							.tableau)[j][i].partie_reelle;
					matrice_f77[k++].partie_imaginaire =
							((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_argument).objet)).tableau)[j][i]
							.partie_imaginaire;
				}
			}

			for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
					.objet)).nombre_lignes; k++)
			{
				matrice_f77[k].partie_reelle = (real8) 0;
				matrice_f77[k].partie_imaginaire = (real8) 0;
			}
		}

		nombre_lignes = (integer4) (*((struct_matrice *) (*s_objet_argument)
				.objet)).nombre_lignes;
		nombre_colonnes = longueur_dft;
		inverse = 0;

		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);

		if (erreur != 0)
		{
			liberation(s_etat_processus, s_objet_argument);
			free(matrice_f77);

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

		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 =
				(*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				longueur_dft;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
				.objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
		{
			(*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)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}

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

		free(matrice_f77);
	}

/*
--------------------------------------------------------------------------------
  Calcul de DFT impossible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

	liberation(s_etat_processus, s_objet_argument);

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

	return;
}


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

void
instruction_der(struct_processus *s_etat_processus)
{
	logical1					expression_rpn;
	logical1					last_valide;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_precedent;

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

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(dérivation)\n\n");
		}
		else
		{
			printf("(derivation)\n\n");
		}

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

		printf("    2: %s, %s\n", d_RPN, d_ALG);
		printf("    1: %s\n", d_NOM);
		printf("->  1: %s, %s\n", d_RPN, d_ALG);

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

	if ((last_valide = 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;
	}

	expression_rpn = d_faux;

	/*
	 * Dérivation d'une expression
	 */

	if (((*s_objet_argument_1).type == NOM) &&
			(((*s_objet_argument_2).type == RPN) ||
			((*s_objet_argument_2).type == ALG)))
	{
		if ((s_copie_argument_2 = copie_objet(s_etat_processus,
				s_objet_argument_2, 'N')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_copie_argument_2).type == RPN)
		{
			expression_rpn = d_vrai;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_copie_argument_2).objet;
		l_element_precedent = l_element_courant;

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

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

		(*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
		l_element_precedent = (*l_element_precedent).suivant;

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

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

		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).nombre_arguments = 2;
		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).fonction = instruction_der;

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

		strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
				.suivant).donnee).objet)).nom_fonction, "DER");

		(*(*l_element_precedent).suivant).suivant = l_element_courant;

		s_objet_resultat = s_copie_argument_2;
		s_objet_argument_1 = NULL;
	}

	/*
	 * Dérivation d'un nom ou d'une constante
	 */

	else if (((*s_objet_argument_1).type == NOM) &&
			(((*s_objet_argument_2).type == NOM) ||
			((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL) ||
			((*s_objet_argument_2).type == CPL)))
	{
		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 (((*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;
		(*l_element_courant).donnee = s_objet_argument_2;

		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;
		(*l_element_courant).donnee = s_objet_argument_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, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 2;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_der;

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

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

		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;

		s_objet_argument_1 = NULL;
		s_objet_argument_2 = NULL;
	}

	/*
	 * Dérivation impossible
	 */

	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 (expression_rpn == d_faux)
	{
		if (last_valide == d_vrai)
		{
			cf(s_etat_processus, 31);
		}

		derivation(s_etat_processus, &s_objet_resultat);

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

		if (((*s_etat_processus).var_volatile_requete_arret == 0) &&
				(s_objet_resultat != NULL))
		{
			if ((s_objet_simplifie = simplification(s_etat_processus,
					s_objet_resultat)) == NULL)
			{
				liberation(s_etat_processus, s_objet_resultat);
				return;
			}

			liberation(s_etat_processus, s_objet_resultat);

			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_simplifie) == d_erreur)
			{
				return;
			}
		}
		else
		{
			if (s_objet_resultat != NULL)
			{
				liberation(s_etat_processus, s_objet_resultat);
			}
		}
	}
	else
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_resultat) == d_erreur)
		{
			return;
		}
	}

	return;
}


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

void
instruction_detach(struct_processus *s_etat_processus)
{
	int									pipe_initialisation_segment_signaux[2];

	logical1							drapeau;

	pid_t								ppid;

	pthread_attr_t						attributs;

	pthread_mutexattr_t					attributs_mutex;

	pthread_t							thread_surveillance;

	sig_atomic_t						registre_stop;

	ssize_t								longueur_ecriture;

	struct_descripteur_thread			*s_argument_thread;
	struct_descripteur_thread			*s_argument_thread2;

	struct_liste_chainee				*l_element_courant;
	struct_liste_chainee				*l_element_precedent;
	struct_liste_chainee				*l_element_suivant;

	struct_liste_variables_partagees	*l_element_partage_courant;
	struct_liste_variables_partagees	*l_element_partage_suivant;

	struct_liste_variables_statiques	*l_element_statique_courant;
	struct_liste_variables_statiques	*l_element_statique_suivant;

	struct_objet						*s_copie;
	struct_objet						*s_objet;
	struct_objet						*s_objet_systeme;
	struct_objet						*s_objet_temporaire;

	struct sigaction					action;
	struct sigaction					registre;

	struct timespec						attente;

	unsigned char						caractere;
	unsigned char						*message;

	unsigned int						erreur;

	integer8							i;

	volatile logical1					variable_partagee;

	(*s_etat_processus).erreur_execution = d_ex;

	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;
	s_copie = NULL;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(détachement d'un processus)\n\n");
		}
		else
		{
			printf("(fork)\n\n");
		}

		printf("    1: %s, %s\n", d_NOM, d_RPN);
		printf("->  1: %s\n", d_PRC);

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

	/*
	 * Une routine fille doit pouvoir renvoyer des objets au processus
	 * père au travers de la fonction SEND. Il ne peut donc s'agir que
	 * d'une fonction ou d'une expression RPN.
	 */

	if (((*s_objet).type != NOM) && ((*s_objet).type != RPN))
	{
		liberation(s_etat_processus, s_objet);

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

	/*
	 * Si l'argument est de type NOM, il faut que la variable correspondante
	 * soit une variable de type RPN.
	 */

	variable_partagee = d_faux;

	if ((*s_objet).type == NOM)
	{
		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet).objet)).nom) == d_vrai)
		{
			if ((*(*s_etat_processus).pointeur_variable_courante).objet
					== NULL)
			{
				if (recherche_variable_partagee(s_etat_processus,
						(*(*s_etat_processus).pointeur_variable_courante).nom,
						(*(*s_etat_processus).pointeur_variable_courante)
						.variable_partagee, (*(*s_etat_processus)
						.pointeur_variable_courante).origine) == NULL)
				{
					liberation(s_etat_processus, s_objet);

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

				if (((*(*(*s_etat_processus)
						.pointeur_variable_partagee_courante).objet).type
						== RPN) && ((*(*(*s_etat_processus)
						.pointeur_variable_partagee_courante).objet).type
						== ADR))
				{
					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);

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

				if ((s_copie = copie_objet(s_etat_processus,
						(*(*s_etat_processus)
						.pointeur_variable_partagee_courante).objet, 'P'))
						== NULL)
				{
					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;
				}

				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;
				}
			}
			else
			{
				if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
						.type != RPN) && ((*(*(*s_etat_processus)
						.pointeur_variable_courante).objet).type != ADR))
				{
					liberation(s_etat_processus, s_objet);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}
			}
		}
		else // Variable inexistante
		{
			liberation(s_etat_processus, s_objet);

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

	if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_erreurs) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_interruptions) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_nombre_elements_attente) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_objets) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_acquittement) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_injections) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pipe(pipe_initialisation_segment_signaux) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	ppid = getpid();

	/*
	 * Le mutex suivant permet de copier un contexte propre.
	 */

	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	verrouillage_threads_concurrents(s_etat_processus);

	if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	fflush(NULL);

	/*
	 * On bloque tous les threads concurents pour qu'il n'y ait ni allocation
	 * de mémoire, ni libération, ni copie d'objet concurrent au fork().
	 */

	(*s_argument_thread).pid = fork();

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

	if ((*s_argument_thread).pid > 0)
	{
		// On ne déverrouille les threads concurrents que dans le processus
		// père. Dans le fils, les valeurs sont non initialisées.
		deverrouillage_threads_concurrents(s_etat_processus);
	}

	(*s_argument_thread).thread_pere = pthread_self();
	(*s_argument_thread).processus_detache = d_vrai;

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references),
			&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	if ((*s_argument_thread).pid > 0)
	{
		/*
		 * Processus père
		 */

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

		if (variable_partagee == d_vrai)
		{
			liberation(s_etat_processus, s_copie);
		}

		liberation(s_etat_processus, s_objet);

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

		(*((struct_processus_fils *) (*s_objet).objet)).thread =
				s_argument_thread;
		(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
				.nombre_objets_dans_pipe = 0;
		(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
				.nombre_interruptions_dans_pipe = 0;
		(*(*((struct_processus_fils *) (*s_objet).objet)).thread)
				.nombre_references = 1;

		/*
		 * On copie l'objet plutôt que le pointeur car cet objet peut être
		 * accédé depuis deux threads distincts et aboutir à un blocage lors
		 * d'une copie.
		 */

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

		if (close((*s_argument_thread).pipe_erreurs[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_interruptions[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_nombre_elements_attente[1])
				!= 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_objets[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_injections[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_nombre_injections[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (close((*s_argument_thread).pipe_acquittement[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pthread_attr_init(&attributs) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pthread_attr_setdetachstate(&attributs,
				PTHREAD_CREATE_DETACHED) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

#		ifdef SCHED_OTHER
		if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
#		endif

#		ifdef PTHREAD_EXPLICIT_SCHED
		if (pthread_attr_setinheritsched(&attributs,
				PTHREAD_EXPLICIT_SCHED) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
#		endif

#		ifdef PTHREAD_SCOPE_SYSTEM
		if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
#		endif

		(*s_argument_thread).s_etat_processus = s_etat_processus;

		if (pthread_create(&thread_surveillance, &attributs,
				surveillance_processus, s_argument_thread) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pthread_attr_destroy(&attributs) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_argument_thread).pid == 0)
	{
		/*
		 * Processus fils
		 */

		// EPERM
#if 0
		pthread_mutex_destroy(&mutex_liste_variables_partagees);
		pthread_mutex_destroy(&mutex_liste_threads);
		pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus);
		pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
#endif
		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
		pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
		pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
		pthread_mutex_init(&mutex_liste_threads_surveillance, &attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
		pthread_mutex_init(&mutex_sigaction, &attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
		pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus),
				&attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
		pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
				&attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		liberation_queue_signaux(s_etat_processus);
		creation_queue_signaux(s_etat_processus);

		routine_recursive = 0;
		nombre_threads_surveillance_processus = 0;

		(*s_etat_processus).pointeur_signal_lecture = 0;
		(*s_etat_processus).pointeur_signal_ecriture = 0;

		if (write_atomic(s_etat_processus,
				pipe_initialisation_segment_signaux[1],
				"-", sizeof(unsigned char)) != sizeof(unsigned char))
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}

		close(pipe_initialisation_segment_signaux[0]);
		close(pipe_initialisation_segment_signaux[1]);

		if ((*s_etat_processus).debug == d_vrai)
			if (((*s_etat_processus).type_debug &
					d_debug_processus) != 0)
		{
			if ((*s_etat_processus).langue == 'F')
			{
				printf("[%d] Lancement du processus fils %d de %d\n",
						(int) getpid(), (int) getpid(), (int) ppid);
			}
			else
			{
				printf("[%d] Start child process %d from %d\n", (int) getpid(),
						(int) getpid(), (int) ppid);
			}

			fflush(stdout);
		}

		if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread).pipe_interruptions[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread)
				.pipe_nombre_elements_attente[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread).pipe_objets[0]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread).pipe_injections[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread).pipe_nombre_injections[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (close((*s_argument_thread).pipe_acquittement[1]) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}

		if ((*s_etat_processus).debug == d_vrai)
			if (((*s_etat_processus).type_debug &
					d_debug_processus) != 0)
		{
			if ((*s_etat_processus).langue == 'F')
			{
				printf("[%d] Libération des objets du processus père\n",
						(int) getpid());
			}
			else
			{
				printf("[%d] Freeing parent process memory\n", getpid());
			}

			fflush(stdout);
		}

		l_element_courant = (*s_etat_processus).liste_mutexes;
		while(l_element_courant != NULL)
		{
			liberation(s_etat_processus, (*l_element_courant).donnee);
			l_element_suivant = (*l_element_courant).suivant;
			free(l_element_courant);
			l_element_courant = l_element_suivant;
		}

		(*s_etat_processus).liste_mutexes = NULL;

		liberation_threads(s_etat_processus);
		insertion_thread(s_etat_processus, d_vrai);

		// Envoi d'une donnée pour signaler le démarrage du processus au thread
		// de surveillance.

		caractere = 0;

		if (write_atomic(s_etat_processus,
				(*s_argument_thread).pipe_nombre_elements_attente[1],
				&caractere, sizeof(caractere)) != sizeof(caractere))
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		if (pthread_mutex_destroy(&mutex_sections_critiques) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		pthread_mutexattr_init(&attributs_mutex);
		pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
		pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
		pthread_mutexattr_destroy(&attributs_mutex);

		if ((*s_etat_processus).evaluation_expression_compilee == 'N')
		{
			free((*s_etat_processus).instruction_courante);
			(*s_etat_processus).instruction_courante = NULL;
		}

		(*s_etat_processus).var_volatile_processus_pere = 0;
		(*s_etat_processus).var_volatile_processus_racine = 0;

		// On réinitialise toutes les interruptions.

		(*s_etat_processus).traitement_interruption = 'N';
		(*s_etat_processus).traitement_interruptible = 'Y';
		(*s_etat_processus).nombre_interruptions_en_queue = 0;
		(*s_etat_processus).nombre_interruptions_non_affectees = 0;
		(*s_etat_processus).processus_detache = d_vrai;

		liberation(s_etat_processus, (*s_etat_processus).at_exit);
		(*s_etat_processus).at_exit = NULL;
		liberation(s_etat_processus, (*s_etat_processus).at_poke);
		(*s_etat_processus).at_poke = NULL;
		(*s_etat_processus).traitement_at_poke = 'N';

		for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
		{
			liberation(s_etat_processus,
					(*s_etat_processus).corps_interruptions[i]);

			(*s_etat_processus).corps_interruptions[i] = NULL;
			(*s_etat_processus).masque_interruptions[i] = 'N';
			(*s_etat_processus).queue_interruptions[i] = 0;

			l_element_courant = (*s_etat_processus)
					.pile_origine_interruptions[i];

			while(l_element_courant != NULL)
			{
				l_element_suivant = (*l_element_courant).suivant;
				liberation(s_etat_processus, (*l_element_courant).donnee);
				free(l_element_courant);
				l_element_courant = l_element_suivant;
			}

			(*s_etat_processus).pile_origine_interruptions[i] = NULL;
		}

		/*
		 * On bloque l'exécution du processus fils jusqu'à ce que
		 * le père ait renseigné correctement la pile des processus.
		 * Dans le cas contraire, on pourrait essayer de traiter
		 * un RECV sur un système chargé avant que cette pile soit
		 * renseignée.
		 */

		// Attente de la réception du signal rpl_sigstart.

		for((*s_etat_processus).demarrage_fils = d_faux;
				(*s_etat_processus).demarrage_fils != d_vrai;
				nanosleep(&attente, NULL))
		{
			scrutation_interruptions(s_etat_processus);
		}

		(*s_etat_processus).niveau_initial = (*s_etat_processus).niveau_courant;
		(*s_etat_processus).presence_pipes = d_vrai;
		(*s_etat_processus).debug_programme = d_faux;
		(*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];
		(*s_etat_processus).pipe_nombre_elements_attente = (*s_argument_thread)
				.pipe_nombre_elements_attente[1];
		(*s_etat_processus).pipe_interruptions = (*s_argument_thread)
				.pipe_interruptions[1];
		(*s_etat_processus).pipe_injections =
				(*s_argument_thread).pipe_injections[0];
		(*s_etat_processus).pipe_nombre_injections =
				(*s_argument_thread).pipe_nombre_injections[0];
		(*s_etat_processus).pipe_acquittement =
				(*s_argument_thread).pipe_acquittement[0];
		(*s_etat_processus).nombre_objets_injectes = 0;
		(*s_etat_processus).nombre_objets_envoyes_non_lus = 0;
		(*s_etat_processus).temps_maximal_cpu = 0;
		(*s_etat_processus).presence_fusible = d_faux;
		(*s_etat_processus).thread_fusible = 0;
		(*s_etat_processus).pid_erreur_processus_fils = getpid();
		(*s_etat_processus).sections_critiques = 0;
		(*s_etat_processus).initialisation_scheduler = d_faux;

		if ((*s_etat_processus).profilage == d_vrai)
		{
			liberation_profil(s_etat_processus);
		}

		(*s_etat_processus).pile_profilage = NULL;

		if ((*s_etat_processus).generateur_aleatoire != NULL)
		{
			liberation_generateur_aleatoire(s_etat_processus);
		}

		(*s_etat_processus).generateur_aleatoire = NULL;

		if ((*s_etat_processus).instruction_derniere_erreur != NULL)
		{
			free((*s_etat_processus).instruction_derniere_erreur);
			(*s_etat_processus).instruction_derniere_erreur = NULL;
		}

		/*
		 * Initialisation de la pile des processus. Cette pile est effacée
		 * par liberation_threads().
		 */

		if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
				!= 0)
		{
			(*s_etat_processus).erreur_systeme = d_es;

			caractere = 0;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).l_base_pile_processus;

		while(l_element_courant != NULL)
		{
			s_argument_thread2 = (struct_descripteur_thread *)
					(*((struct_processus_fils *) (*(*l_element_courant).donnee)
					  .objet)).thread;

			(*s_argument_thread2).nombre_references--;

			BUG((*s_argument_thread2).nombre_references < 0,
					destruction_queue_signaux(s_etat_processus),
					printf("(*s_argument_thread2).nombre_references = %d\n",
					(int) (*s_argument_thread2).nombre_references));

			if ((*s_argument_thread2).nombre_references == 0)
			{
				close((*s_argument_thread2).pipe_objets[0]);
				close((*s_argument_thread2).pipe_acquittement[1]);
				close((*s_argument_thread2).pipe_injections[1]);
				close((*s_argument_thread2).pipe_nombre_injections[1]);
				close((*s_argument_thread2).pipe_nombre_elements_attente[0]);
				close((*s_argument_thread2).pipe_interruptions[0]);

				pthread_mutex_destroy(&((*s_argument_thread2).mutex));

				if ((*s_argument_thread2).processus_detache == d_faux)
				{
					if ((*s_argument_thread2).destruction_objet == d_vrai)
					{
						liberation(s_etat_processus,
								(*s_argument_thread2).argument);
					}
				}

				free(s_argument_thread2);
				free((*(*l_element_courant).donnee).objet);
				free((*l_element_courant).donnee);
			}

			l_element_suivant = (*l_element_courant).suivant;
			free((struct_liste_chainee *) l_element_courant);
			l_element_courant = l_element_suivant;
		}

		(*s_etat_processus).l_base_pile_processus = NULL;

		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
				!= 0)
		{
			(*s_etat_processus).erreur_systeme = d_es;

			caractere = 0;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		/*
		 * Initialisation de la pile système
		 */

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).l_base_pile_systeme;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (struct_liste_chainee *)
					(*((struct_liste_pile_systeme *)
					l_element_courant)).suivant;

			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).indice_boucle);
			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).limite_indice_boucle);
			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).objet_de_test);

			if ((*((struct_liste_pile_systeme *) l_element_courant))
					.nom_variable != NULL)
			{
				free((*((struct_liste_pile_systeme *)
						l_element_courant)).nom_variable);
			}

			free((struct_liste_pile_systeme *) l_element_courant);

			l_element_courant = l_element_suivant;
		}

		(*s_etat_processus).l_base_pile_systeme = NULL;
		(*s_etat_processus).hauteur_pile_systeme = 0;

		empilement_pile_systeme(s_etat_processus);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			caractere = 0;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).s_marques;

		while(l_element_courant != NULL)
		{
			free((*((struct_marque *) l_element_courant)).label);
			free((*((struct_marque *) l_element_courant)).position);
			l_element_suivant = (struct_liste_chainee *)
					(*((struct_marque *) l_element_courant)).suivant;
			free((struct_marque *) l_element_courant);
			l_element_courant = l_element_suivant;
		}

		(*s_etat_processus).s_marques = NULL;

		/*
		 * On empile deux valeurs retour_definition pour pouvoir récupérer
		 * les variables dans le cas d'un programme compilé.
		 */

		empilement_pile_systeme(s_etat_processus);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			caractere = 0;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_nombre_elements_attente[1],
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}

			destruction_queue_signaux(s_etat_processus);
			BUG(1, uprintf("Process management error line %d\n", __LINE__));
			exit(EXIT_FAILURE);
		}

		(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';

		/*
		 * Destruction des sorties graphiques et PostScript
		 */

		while((*s_etat_processus).fichiers_graphiques != NULL)
		{
			free((*(*s_etat_processus).fichiers_graphiques).nom);

			if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
			{
				free((*(*s_etat_processus).fichiers_graphiques).legende);
			}

			l_element_precedent = (void *) (*s_etat_processus)
					.fichiers_graphiques;
			(*s_etat_processus).fichiers_graphiques =
					(*(*s_etat_processus).fichiers_graphiques).suivant;
			free(l_element_precedent);
		}

		if ((*s_etat_processus).entree_standard != NULL)
		{
			pclose((*s_etat_processus).entree_standard);
			(*s_etat_processus).entree_standard = NULL;
		}

		(*s_etat_processus).requete_nouveau_plan = d_vrai;
		(*s_etat_processus).mise_a_jour_trace_requise = d_faux;

		if ((*s_etat_processus).nom_fichier_impression != NULL)
		{
			free((*s_etat_processus).nom_fichier_impression);
			(*s_etat_processus).nom_fichier_impression = NULL;
		}

		/*
		 * Destruction des piles de fichiers
		 */

		l_element_courant = (*s_etat_processus).s_fichiers;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			fclose((*((struct_descripteur_fichier *)
					(*l_element_courant).donnee)).descripteur_c);

			if ((*((struct_descripteur_fichier *)
					(*l_element_courant).donnee)).type != 'C')
			{
				sqlite3_close((*((struct_descripteur_fichier *)
						(*l_element_courant).donnee)).descripteur_sqlite);
			}

			free((*((struct_descripteur_fichier *) (*l_element_courant)
					.donnee)).nom);
			free((struct_descripteur_fichier *) (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		(*s_etat_processus).s_fichiers = NULL;

		/*
		 * Destruction des piles de connecteurs SQL
		 */

/*
================================================================================
  À noter : on ne ferme pas la connexion car la conséquence immédiate est
  une destruction de l'objet pour le processus père.
================================================================================
*/

		l_element_courant = (*s_etat_processus).s_connecteurs_sql;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

//			sqlclose((*l_element_courant).donnee);
			liberation(s_etat_processus, (*l_element_courant).donnee);
			l_element_courant = l_element_suivant;
		}

		/*
		 * On ne détruit pas les sockets car il faut utiliser DETACH
		 * pour traiter plusieurs connexions simultanées sur les sockets
		 */

		(*s_etat_processus).s_connecteurs_sql = NULL;

		if ((*s_etat_processus).debug == d_vrai)
		{
			if (((*s_etat_processus).type_debug & d_debug_processus)
					!= 0)
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("[%d] Évaluation de l'objet détaché\n", getpid());
				}
				else
				{
					printf("[%d] Évaluation of detached object\n", getpid());
				}
			}
		}

		if ((*s_etat_processus).erreur_systeme == d_es)
		{
			// Évite le warning variable s_copie might be clobbered by
			// longjmp or vfork
			struct_objet **s;

			if ((s = malloc(sizeof(struct_objet *))) == NULL)
			{
				(*s_etat_processus).erreur_execution = d_es_allocation_memoire;
				return;
			}

			(*s) = s_copie;

			if (setjmp(contexte_processus) == 0)
			{
				if (variable_partagee == d_faux)
				{
					if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)
					{
						if (((*s_etat_processus).erreur_execution == d_ex) &&
								((*s_etat_processus).erreur_systeme == d_es))
						{
							(*s_etat_processus).erreur_execution =
									d_ex_erreur_evaluation;
						}
					}
					else
					{
						if (((*s_etat_processus).arret_depuis_abort == 0)
								&& ((*s_etat_processus).at_exit != NULL))
						{
							(*s_etat_processus).var_volatile_requete_arret = 0;
							(*s_etat_processus).var_volatile_alarme = 0;
							(*s_etat_processus).var_volatile_traitement_sigint
									= 0;

							if ((*s_etat_processus).profilage == d_vrai)
							{
								profilage(s_etat_processus, "ATEXIT");
							}

							if (evaluation(s_etat_processus,
									(*s_etat_processus).at_exit, 'E') ==
									d_erreur)
							{
								(*s_etat_processus).erreur_execution =
										d_ex_erreur_evaluation;
							}

							if ((*s_etat_processus).profilage == d_vrai)
							{
								profilage(s_etat_processus, NULL);
							}
						}
					}
				}
				else
				{
					if (evaluation(s_etat_processus, (*s), 'E') == d_erreur)
					{
						if (((*s_etat_processus).erreur_execution == d_ex) &&
								((*s_etat_processus).erreur_systeme == d_es))
						{
							(*s_etat_processus).erreur_execution =
									d_ex_erreur_evaluation;
						}
					}
					else
					{
						if (((*s_etat_processus).arret_depuis_abort == 0)
								&& ((*s_etat_processus).at_exit != NULL))
						{
							(*s_etat_processus).var_volatile_requete_arret = 0;
							(*s_etat_processus).var_volatile_alarme = 0;
							(*s_etat_processus).var_volatile_traitement_sigint
									= 0;

							if ((*s_etat_processus).profilage == d_vrai)
							{
								profilage(s_etat_processus, "ATEXIT");
							}

							if (evaluation(s_etat_processus,
									(*s_etat_processus).at_exit, 'E') ==
									d_erreur)
							{
								(*s_etat_processus).erreur_execution =
										d_ex_erreur_evaluation;
							}

							if ((*s_etat_processus).profilage == d_vrai)
							{
								profilage(s_etat_processus, NULL);
							}
						}
					}

					liberation(s_etat_processus, (*s));
				}
			}

			free(s);
		}

		for(i = 0; i < (*s_etat_processus).sections_critiques; i++)
		{
			pthread_mutex_unlock(&mutex_sections_critiques);
		}

		liberation(s_etat_processus, (*s_etat_processus).at_exit);
		liberation(s_etat_processus, (*s_etat_processus).at_poke);

		l_element_courant = (*s_etat_processus).liste_mutexes;
		while(l_element_courant != NULL)
		{
			liberation(s_etat_processus, (*l_element_courant).donnee);
			l_element_suivant = (*l_element_courant).suivant;
			free(l_element_courant);
			l_element_courant = l_element_suivant;
		}

		if ((*s_etat_processus).presence_fusible == d_vrai)
		{
			pthread_cancel((*s_etat_processus).thread_fusible);
		}

		caractere = 0;

		while((longueur_ecriture = write_atomic(s_etat_processus,
				(*s_argument_thread).pipe_nombre_elements_attente[1],
				&caractere, sizeof(caractere))) != sizeof(caractere))
		{
			if (longueur_ecriture == -1)
			{
				break;
			}
		}

		if ((*s_etat_processus).var_volatile_processus_pere != 0)
		{
			// Racine des processus atteinte

			erreur = d_ex;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_erreurs[1], &erreur,
					sizeof((*s_etat_processus).erreur_execution))) !=
					sizeof((*s_etat_processus).erreur_execution))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}
		else
		{
			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_erreurs[1],
					(int *) &((*s_etat_processus).erreur_execution),
					sizeof((*s_etat_processus).erreur_execution))) !=
					sizeof((*s_etat_processus).erreur_execution))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}

		if ((*s_etat_processus).var_volatile_processus_pere != 0)
		{
			// Racine des processus atteinte

			erreur = d_es;

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_erreurs[1], &erreur,
					sizeof((*s_etat_processus).erreur_systeme))) !=
					sizeof((*s_etat_processus).erreur_systeme))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}
		else
		{
			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_erreurs[1],
					(int *) &((*s_etat_processus).erreur_systeme),
					sizeof((*s_etat_processus).erreur_systeme))) !=
					sizeof((*s_etat_processus).erreur_systeme))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}

		if ((*s_etat_processus).pid_erreur_processus_fils == 0)
		{
			while((longueur_ecriture = write_atomic(s_etat_processus, 
					(*s_argument_thread).pipe_erreurs[1],
					&ppid, sizeof(ppid))) != sizeof(ppid))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}
		else
		{
			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_argument_thread).pipe_erreurs[1],
					&((*s_etat_processus).pid_erreur_processus_fils),
					sizeof((*s_etat_processus).pid_erreur_processus_fils))) !=
					sizeof((*s_etat_processus).pid_erreur_processus_fils))
			{
				if (longueur_ecriture == -1)
				{
					break;
				}
			}
		}

		l_element_courant = (*s_etat_processus).s_fichiers;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			fclose((*((struct_descripteur_fichier *)
					(*l_element_courant).donnee)).descripteur_c);

			if ((*((struct_descripteur_fichier *)
					(*l_element_courant).donnee)).type != 'C')
			{
				sqlite3_close((*((struct_descripteur_fichier *)
						(*l_element_courant).donnee)).descripteur_sqlite);
			}

			if (((*((struct_descripteur_fichier *) (*l_element_courant)
					.donnee)).pid == getpid()) &&
					(pthread_equal((*((struct_descripteur_fichier *)
					(*l_element_courant).donnee)).tid, pthread_self()) != 0))
			{
				if ((*((struct_descripteur_fichier *) (*l_element_courant)
						.donnee)).effacement == 'Y')
				{
					unlink((*((struct_descripteur_fichier *)
							(*l_element_courant).donnee)).nom);
				}
			}

			free((*((struct_descripteur_fichier *) (*l_element_courant)
					.donnee)).nom);
			free((struct_descripteur_fichier *) (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).l_base_pile_processus;

		while(l_element_courant != NULL)
		{
			if ((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *)
					l_element_courant)).donnee).objet)).thread)
					.processus_detache == d_vrai)
			{
				if ((*s_etat_processus).debug == d_vrai)
				{
					if (((*s_etat_processus).type_debug & d_debug_processus)
							!= 0)
					{
						if ((*s_etat_processus).langue == 'F')
						{
							printf("[%d] Signalement pour arrêt du "
									"processus %d\n",
									(int) getpid(),
									(int) (*(*((struct_processus_fils *)
									(*(*((struct_liste_chainee *)
									l_element_courant)).donnee).objet))
									.thread).pid);
						}
						else
						{
							printf("[%d] Send stop signal to process %d\n",
									(int) getpid(),
									(int) (*(*((struct_processus_fils *)
									(*(*((struct_liste_chainee *)
									l_element_courant)).donnee).objet))
									.thread).pid);
						}
					}
				}

				if ((*s_etat_processus).var_volatile_alarme != 0)
				{
					envoi_signal_processus((*(*((struct_processus_fils *)
							(*(*l_element_courant).donnee).objet)).thread).pid,
							rpl_sigurg, d_faux);
				}
				else
				{
					if ((*s_etat_processus).arret_depuis_abort == -1)
					{
						envoi_signal_processus((*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid, rpl_sigabort, d_faux);
					}
					else
					{
						envoi_signal_processus((*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid, rpl_sigstop, d_faux);
					}
				}
			}
			else
			{
				if ((*s_etat_processus).debug == d_vrai)
				{
					if (((*s_etat_processus).type_debug & d_debug_processus)
							!= 0)
					{
						if ((*s_etat_processus).langue == 'F')
						{
							printf("[%d] Signalement pour arrêt du "
									"thread %llu\n",
									(int) getpid(), (unsigned long long)
									(*(*((struct_processus_fils *)
									(*(*((struct_liste_chainee *)
									l_element_courant)).donnee).objet)).thread)
									.tid);
						}
						else
						{
							printf("[%d] Send stop signal to thread %llu\n",
									(int) getpid(), (unsigned long long)
									(*(*((struct_processus_fils *)
									(*(*((struct_liste_chainee *)
									l_element_courant)).donnee).objet)).thread)
									.tid);
						}
					}
				}

				pthread_mutex_lock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).mutex));

				if ((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread)
						.thread_actif == d_vrai)
				{
					if ((*s_etat_processus).var_volatile_alarme != 0)
					{
						envoi_signal_thread(s_etat_processus,
								(*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.tid, rpl_sigurg);
					}
					else
					{
						if ((*s_etat_processus).arret_depuis_abort == -1)
						{
							envoi_signal_thread(s_etat_processus,
									(*(*((struct_processus_fils *)
									(*(*l_element_courant).donnee).objet))
									.thread).tid, rpl_sigabort);
						}
						else
						{
							envoi_signal_thread(s_etat_processus,
									(*(*((struct_processus_fils *)
									(*(*l_element_courant).donnee).objet))
									.thread).tid, rpl_sigstop);
						}
					}
				}

				pthread_mutex_unlock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).mutex));
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		/*
		 * Attente de la fin de tous les processus fils
		 */

		for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
				(*s_etat_processus).masque_interruptions[i++] = 'I');

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

		while((*s_etat_processus).l_base_pile_processus != NULL)
		{
			l_element_courant = (struct_liste_chainee *)
					(*s_etat_processus).l_base_pile_processus;

			registre_stop = (*s_etat_processus)
					.var_volatile_traitement_retarde_stop;
			(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;

			for(i = 0; i < (*(*((struct_processus_fils *)
					(*(*l_element_courant)
					.donnee).objet)).thread).nombre_objets_dans_pipe; i++)
			{
				if ((s_objet_temporaire = lecture_pipe(s_etat_processus,
						(*(*((struct_processus_fils *) (*(*l_element_courant)
						.donnee).objet)).thread).pipe_objets[0])) != NULL)
				{
					liberation(s_etat_processus, s_objet_temporaire);

					(*(*((struct_processus_fils *) (*(*l_element_courant)
							.donnee).objet)).thread).nombre_objets_dans_pipe--;

					if (pthread_mutex_lock(&mutex_sigaction) != 0)
					{
						destruction_queue_signaux(s_etat_processus);
						(*s_etat_processus).erreur_systeme = d_es_processus;
						exit(EXIT_FAILURE);
					}

					action.sa_handler = SIG_IGN;
					action.sa_flags = 0;

					if (sigaction(SIGPIPE, &action, &registre) != 0)
					{
						pthread_mutex_unlock(&((*s_etat_processus)
								.mutex_pile_processus));
						pthread_mutex_unlock(&mutex_sigaction);

						if (registre_stop == 0)
						{
							if ((*s_etat_processus)
									.var_volatile_traitement_retarde_stop
									== -1)
							{
								(*s_etat_processus)
										.var_volatile_requete_arret = -1;
							}

							(*s_etat_processus)
									.var_volatile_traitement_retarde_stop =
									registre_stop;
						}

						destruction_queue_signaux(s_etat_processus);
						(*s_etat_processus).erreur_systeme = d_es_signal;
						exit(EXIT_FAILURE);
					}

					while((longueur_ecriture = write_atomic(
							s_etat_processus, (*(*((struct_processus_fils *)
							(*(*l_element_courant).donnee).objet))
							.thread).pipe_nombre_injections[1], "+",
							sizeof(unsigned char))) !=
							sizeof(unsigned char))
					{
						if (longueur_ecriture == -1)
						{
							// Le processus n'existe plus.
							break;
						}
					}

					if (registre_stop == 0)
					{
						if ((*s_etat_processus)
								.var_volatile_traitement_retarde_stop == -1)
						{
							(*s_etat_processus).var_volatile_requete_arret
									= -1;
						}

						(*s_etat_processus)
								.var_volatile_traitement_retarde_stop =
								registre_stop;
					}

					if (sigaction(SIGPIPE, &registre, NULL) != 0)
					{
						destruction_queue_signaux(s_etat_processus);

						pthread_mutex_unlock(&mutex_sigaction);
						pthread_mutex_unlock(&((*s_etat_processus)
								.mutex_pile_processus));
						(*s_etat_processus).erreur_systeme = d_es_signal;
						exit(EXIT_FAILURE);
					}

					if (pthread_mutex_unlock(&mutex_sigaction) != 0)
					{
						destruction_queue_signaux(s_etat_processus);
						pthread_mutex_unlock(&((*s_etat_processus)
								.mutex_pile_processus));
						(*s_etat_processus).erreur_systeme = d_es_processus;
						exit(EXIT_FAILURE);
					}
				}
			}

			if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions))
					!= 0)
			{
				destruction_queue_signaux(s_etat_processus);

				pthread_mutex_unlock(&((*s_etat_processus)
						.mutex_pile_processus));
				(*s_etat_processus).erreur_systeme = d_es_processus;
				exit(EXIT_FAILURE);
			}

			if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
			{
				affectation_interruptions_logicielles(s_etat_processus);
			}

			if (pthread_mutex_unlock(&((*s_etat_processus)
					.mutex_interruptions)) != 0)
			{
				destruction_queue_signaux(s_etat_processus);

				pthread_mutex_unlock(&((*s_etat_processus)
						.mutex_pile_processus));
				(*s_etat_processus).erreur_systeme = d_es_processus;
				exit(EXIT_FAILURE);
			}

			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
			nanosleep(&attente, NULL);
			pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));

			scrutation_interruptions(s_etat_processus);
		}

		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));

		l_element_courant = (*s_etat_processus).s_sockets;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			if ((*((struct_socket *) (*(*l_element_courant).donnee)
					.objet)).socket_connectee == d_vrai)
			{
				shutdown((*((struct_socket *) (*(*l_element_courant).donnee)
						.objet)).socket, SHUT_RDWR);
			}

			close((*((struct_socket *) (*(*l_element_courant).donnee)
					.objet)).socket);

			if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
					.pid == getpid()) && (pthread_equal((*((struct_socket *)
					(*(*l_element_courant).donnee).objet)).tid, pthread_self())
					!= 0))
			{
				if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
						.effacement == 'Y')
				{
					unlink((*((struct_socket *) (*(*l_element_courant).donnee)
							.objet)).adresse);
				}
			}

			liberation(s_etat_processus,
					(*((struct_liste_chainee *) l_element_courant)).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		l_element_courant = (*s_etat_processus).s_connecteurs_sql;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			sqlclose((*l_element_courant).donnee);

			liberation(s_etat_processus,
					(*((struct_liste_chainee *) l_element_courant)).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		if ((((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_systeme != d_es)) &&
				((*s_etat_processus).var_volatile_traitement_sigint == 0))
		{
			printf("%s [%d]\n", message =
					messages(s_etat_processus), (int) getpid());
			free(message);

			if ((*s_etat_processus).core == d_vrai)
			{
				printf("\n");
				
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Information : Génération du fichier rpl-core "
							"[%d]\n", (int) getpid());
				}
				else
				{
					printf("+++Information : Writing rpl-core file [%d]\n",
							(int) getpid());
				}

				rplcore(s_etat_processus);

				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Information : Processus tracé [%d]\n",
							(int) getpid());
				}
				else
				{
					printf("+++Information : Done [%d]\n", (int) getpid());
				}

				printf("\n");
				fflush(stdout);
			}
		}

		liberation_arbre_instructions(s_etat_processus,
				(*s_etat_processus).arbre_instructions);
		free((*s_etat_processus).pointeurs_caracteres);

		l_element_statique_courant = (*s_etat_processus)
				.l_liste_variables_statiques;

		while(l_element_statique_courant != NULL)
		{
			l_element_statique_suivant = (*l_element_statique_courant).suivant;
			free(l_element_statique_courant);
			l_element_statique_courant = l_element_statique_suivant;
		}

		l_element_partage_courant = (*(*s_etat_processus)
				.l_liste_variables_partagees);

		while(l_element_partage_courant != NULL)
		{
			l_element_partage_suivant = (*l_element_partage_courant).suivant;
			free(l_element_partage_courant);
			l_element_partage_courant = l_element_partage_suivant;
		}

		if ((*s_etat_processus).entree_standard != NULL)
		{
			pclose((*s_etat_processus).entree_standard);
			(*s_etat_processus).entree_standard = NULL;
		}

		liberation(s_etat_processus, (*s_etat_processus).indep);
		liberation(s_etat_processus, (*s_etat_processus).depend);

		free((*s_etat_processus).label_x);
		free((*s_etat_processus).label_y);
		free((*s_etat_processus).label_z);
		free((*s_etat_processus).titre);
		free((*s_etat_processus).legende);

		liberation(s_etat_processus,
				(*s_etat_processus).parametres_courbes_de_niveau);

		if ((*s_etat_processus).instruction_derniere_erreur != NULL)
		{
			free((*s_etat_processus).instruction_derniere_erreur);
			(*s_etat_processus).instruction_derniere_erreur = NULL;
		}

		liberation_arbre_variables_partagees(s_etat_processus,
				(*(*s_etat_processus).s_arbre_variables_partagees));
		liberation_arbre_variables(s_etat_processus,
				(*s_etat_processus).s_arbre_variables, d_vrai);
		free((*s_etat_processus).pointeurs_caracteres_variables);

		l_element_courant = (*s_etat_processus).l_base_pile;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			liberation(s_etat_processus, (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		l_element_courant = (*s_etat_processus).l_base_pile_last;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			liberation(s_etat_processus, (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		l_element_courant = (*s_etat_processus).l_base_pile_contextes;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			liberation(s_etat_processus, (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			liberation(s_etat_processus, (*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).l_base_pile_systeme;
		while(l_element_courant != NULL)
		{
			l_element_suivant = (struct_liste_chainee *)
					(*((struct_liste_pile_systeme *)
					l_element_courant)).suivant;

			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).indice_boucle);
			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).limite_indice_boucle);
			liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
					l_element_courant)).objet_de_test);

			if ((*((struct_liste_pile_systeme *)
					l_element_courant)).nom_variable != NULL)
			{
				free((*((struct_liste_pile_systeme *)
						l_element_courant)).nom_variable);
			}

			free((struct_liste_pile_systeme *) l_element_courant);

			l_element_courant = l_element_suivant;
		}

		/*
		 * Destruction des bibliothèques
		 */

		l_element_courant = (*s_etat_processus).s_bibliotheques;

		while(l_element_courant != NULL)
		{
			l_element_suivant = (*l_element_courant).suivant;

			free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);

			dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee))
					.descripteur);

			free((*l_element_courant).donnee);
			free(l_element_courant);

			l_element_courant = l_element_suivant;
		}

		for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
		{
			free((*s_etat_processus).s_instructions_externes[i].nom);
			free((*s_etat_processus).s_instructions_externes[i]
					.nom_bibliotheque);
		}

		if ((*s_etat_processus).nombre_instructions_externes != 0)
		{
			free((*s_etat_processus).s_instructions_externes);
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).s_marques;

		while(l_element_courant != NULL)
		{
			free((*((struct_marque *) l_element_courant)).label);
			free((*((struct_marque *) l_element_courant)).position);
			l_element_suivant = (struct_liste_chainee *)
					(*((struct_marque *) l_element_courant)).suivant;
			free((struct_marque *) l_element_courant);
			l_element_courant = l_element_suivant;
		}

		if ((*s_etat_processus).debug == d_vrai)
			if (((*s_etat_processus).type_debug &
					d_debug_processus) != 0)
		{
			if ((*s_etat_processus).langue == 'F')
			{
				printf("[%d] Arrêt du processus\n", (int) getpid());
			}
			else
			{
				printf("[%d] Stop process\n", (int) getpid());
			}

			fflush(stdout);
		}

		liberation(s_etat_processus, s_objet);

		free((*s_etat_processus).definitions_chainees);
		free((*s_etat_processus).nom_fichier_historique);

		for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
		{
			liberation(s_etat_processus,
					(*s_etat_processus).corps_interruptions[i]);

			l_element_courant = (*s_etat_processus)
					.pile_origine_interruptions[i];
				
			while(l_element_courant != NULL)
			{
				l_element_suivant = (*l_element_courant).suivant;

				liberation(s_etat_processus, (*l_element_courant).donnee);
				free(l_element_courant);

				l_element_courant = l_element_suivant;
			}
		}

		if ((*s_etat_processus).generateur_aleatoire != NULL)
		{
			liberation_generateur_aleatoire(s_etat_processus);
		}

		if ((*s_etat_processus).profilage == d_vrai)
		{
			ecriture_profil(s_etat_processus);
			liberation_profil(s_etat_processus);
		}

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

		pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));

		while(nombre_threads_surveillance_processus != 0)
		{
			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
			nanosleep(&attente, NULL);
			INCR_GRANULARITE(attente.tv_nsec);
			pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
		}

		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));

		closelog();

		retrait_thread(s_etat_processus);
		liberation_contexte_cas(s_etat_processus);

		clear_history();

		close((*s_argument_thread).pipe_erreurs[1]);
		close((*s_argument_thread).pipe_interruptions[1]);
		close((*s_argument_thread).pipe_nombre_elements_attente[1]);
		close((*s_argument_thread).pipe_objets[1]);
		close((*s_argument_thread).pipe_injections[0]);
		close((*s_argument_thread).pipe_nombre_injections[0]);
		close((*s_argument_thread).pipe_acquittement[0]);

		free((*s_etat_processus).localisation);
		free((*s_etat_processus).chemin_fichiers_temporaires);
		free(s_argument_thread);

		liberation_allocateur(s_etat_processus);
		liberation_allocateur_buffer(s_etat_processus);

		// Permet d'attendre la libération du mutex de la part
		// de surveillance_processus().

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

		while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus))
				== EBUSY)
		{
			nanosleep(&attente, NULL);
			INCR_GRANULARITE(attente.tv_nsec);
		}

		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));

		// Libération des mutexes.

		pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
		pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
		pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
		pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
		pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
		pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
		pthread_mutex_destroy(&mutex_sections_critiques);
		pthread_mutex_destroy(&mutex_liste_variables_partagees);

		destruction_queue_signaux(s_etat_processus);
		pthread_mutex_destroy(&mutex_liste_threads);
		pthread_mutex_destroy(&mutex_liste_threads_surveillance);

#		ifndef SEMAPHORES_NOMMES
		sem_post(&((*s_etat_processus).semaphore_fork));
		sem_destroy(&((*s_etat_processus).semaphore_fork));
#		else
		sem_post((*s_etat_processus).semaphore_fork);
		sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
				pthread_self(), SEM_FORK);
#		endif

		sys_free(s_etat_processus);

#		ifdef DEBUG_MEMOIRE
		debug_memoire_verification();
		analyse_post_mortem();
#		endif

		pthread_mutex_destroy(&mutex_sigaction);
		exit(EXIT_SUCCESS);
	}
	else
	{
		deverrouillage_threads_concurrents(s_etat_processus);
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	// Si le pid existe déjà dans la pile des processus, il s'agit forcement
	// d'un processus moribond. On attend donc qu'il soit effectivement
	// libéré.

	do
	{
		l_element_courant = (struct_liste_chainee *)
				(*s_etat_processus).l_base_pile_processus;
		drapeau = d_faux;

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

		while(l_element_courant != NULL)
		{
			if ((*(*((struct_processus_fils *)
					(*(*l_element_courant).donnee).objet)).thread)
					.processus_detache == d_vrai)
			{
				if ((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).pid ==
						(*s_argument_thread).pid)
				{
					if (pthread_mutex_unlock(&((*s_etat_processus)
							.mutex_pile_processus)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}

					nanosleep(&attente, NULL);
					INCR_GRANULARITE(attente.tv_nsec);

					if (pthread_mutex_lock(&((*s_etat_processus)
							.mutex_pile_processus)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}

					drapeau = d_vrai;
					break;
				}
			}

			scrutation_interruptions(s_etat_processus);
			l_element_courant = (*l_element_courant).suivant;
		}
	} while(drapeau == d_vrai);

	if (empilement(s_etat_processus,
			(struct_liste_chainee **) &((*s_etat_processus)
			.l_base_pile_processus), s_objet_systeme) == d_erreur)
	{
		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
		return;
	}

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

	// On attend une donnée fictive pour être sûr que le segment de mémoire
	// partagée destiné à la gestion des signaux est bien initialisé.

	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while(read_atomic(s_etat_processus,
			pipe_initialisation_segment_signaux[0],
			&caractere, sizeof(caractere)) == 0)
	{
		scrutation_interruptions(s_etat_processus);
		nanosleep(&attente, NULL);
		INCR_GRANULARITE(attente.tv_nsec);
	}

	close(pipe_initialisation_segment_signaux[0]);
	close(pipe_initialisation_segment_signaux[1]);

	// Le fils peut être présent sans être en attente du signal de départ.

	if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart,
			d_vrai) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
		return;
	}

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

	return;
}

// vim: ts=4