/*
================================================================================
  RPL/2 (R) version 4.0.16
  Copyright (C) 1989-2010 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					nombre_colonnes;
	integer4					nombre_lignes;

	logical1					presence_longueur_dft;

	long						longueur_dft_signee;

	struct_complexe16			*matrice_f77;

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

	unsigned long				i;
	unsigned long				j;
	unsigned long				k;
	unsigned long				longueur_dft;

	(*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 = 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 = (*((struct_vecteur *)
					(*s_objet_argument).objet)).taille;
		}

		if ((matrice_f77 = malloc(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 = (*((struct_matrice *)
					(*s_objet_argument).objet)).nombre_colonnes;
		}

		if ((matrice_f77 = malloc(longueur_dft *
				(*((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 = (*((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((*((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((*((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)
			{
				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							status;

	logical1					drapeau;
	logical1					variable_partagee;

	pid_t						ppid;
	pid_t						pid_final;

	pthread_attr_t				attributs;

	pthread_mutexattr_t			attributs_mutex;

	pthread_t					thread_surveillance;

	sig_atomic_t				registre_stop;

	sigset_t					oldset;
	sigset_t					oldset2;
	sigset_t					set;
	sigset_t					set2;

	ssize_t						longueur_ecriture;

	struct_descripteur_thread	*s_argument_thread;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_precedent;
	struct_liste_chainee		*l_element_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				*message;

	unsigned int				erreur;

	unsigned long				i;

	(*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).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet
					== NULL)
			{
				if (pthread_mutex_lock(&((*(*s_etat_processus)
						.s_liste_variables_partagees).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (recherche_variable_partagee(s_etat_processus,
						(*s_etat_processus).s_liste_variables
						[(*s_etat_processus).position_variable_courante].nom,
						(*s_etat_processus).s_liste_variables
						[(*s_etat_processus).position_variable_courante]
						.variable_partagee, (*s_etat_processus)
						.s_liste_variables[(*s_etat_processus)
						.position_variable_courante].origine) == d_faux)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.s_liste_variables_partagees).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}

					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).s_liste_variables_partagees)
						.table[(*(*s_etat_processus)
						.s_liste_variables_partagees).position_variable].objet)
						.type != RPN) && ((*(*(*s_etat_processus)
						.s_liste_variables_partagees).table
						[(*(*s_etat_processus).s_liste_variables_partagees)
						.position_variable].objet).type != ADR))
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.s_liste_variables_partagees).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).s_liste_variables_partagees).table
						[(*(*s_etat_processus).s_liste_variables_partagees)
						.position_variable].objet, 'P')) == NULL)
				{
					if (pthread_mutex_unlock(&((*(*s_etat_processus)
							.s_liste_variables_partagees).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)
						.s_liste_variables_partagees).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
			else
			{
				if (((*(*s_etat_processus).s_liste_variables
						[(*s_etat_processus).position_variable_courante].objet)
						.type != RPN) && ((*(*s_etat_processus)
						.s_liste_variables[(*s_etat_processus)
						.position_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 (sigemptyset(&set) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (sigaddset(&set, SIGSTART) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	/*
	 * Le signal SIGFSTOP doit être traité !
	 */

	if (sigaddset(&set, SIGFSTOP) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (sigaddset(&set, SIGFABORT) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (sigaddset(&set, SIGURG) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (pthread_sigmask(SIG_BLOCK, &set, &oldset) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		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_interruptions_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_nombre_objets_attente) != 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;
	}

	ppid = getpid();

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

	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 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().
	 */

	sigfillset(&set2);
	pthread_sigmask(SIG_BLOCK, &set2, &oldset2);

	verrouillage_threads_concurrents(s_etat_processus);
	(*s_argument_thread).pid = fork();
	deverrouillage_threads_concurrents(s_etat_processus);

	pthread_sigmask(SIG_SETMASK, &oldset2, NULL);
	sigpending(&set2);

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

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

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

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

		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			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_interruptions_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_nombre_objets_attente[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;
		}

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

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

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

		(*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
		 */

#		ifdef DEBUG_MEMOIRE
		debug_memoire_reinitialisation();
#		endif

#		ifndef SEMAPHORES_NOMMES
		sem_post(&semaphore_gestionnaires_signaux);
		sem_destroy(&semaphore_gestionnaires_signaux);
		sem_init(&semaphore_gestionnaires_signaux, 0, 0);
#		else
		sem_post(semaphore_gestionnaires_signaux);
		sem_destroy2(semaphore_gestionnaires_signaux,
				sem_gestionnaires_signaux);

		if ((semaphore_gestionnaires_signaux = sem_init2(0,
				sem_gestionnaires_signaux)) == SEM_FAILED)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
#		endif

#		ifndef SEMAPHORES_NOMMES
		sem_post(&semaphore_liste_threads);
		sem_destroy(&semaphore_liste_threads);
		sem_init(&semaphore_liste_threads, 0, 1);
#		else
		sem_post(semaphore_liste_threads);
		sem_destroy2(semaphore_liste_threads, sem_liste_threads);

		if ((semaphore_liste_threads = sem_init2(1,
				sem_liste_threads)) == SEM_FAILED)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
#		endif

#		ifndef SEMAPHORES_NOMMES
		sem_destroy(&semaphore_gestionnaires_signaux_atomique);
		sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
		sem_trywait(&((*s_etat_processus).semaphore_fork));
#		else
		sem_destroy2(semaphore_gestionnaires_signaux_atomique,
				sem_gestionnaires_signaux_atomique);

		if ((semaphore_gestionnaires_signaux_atomique = sem_init2(1,
				sem_gestionnaires_signaux_atomique)) == SEM_FAILED)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}

		sem_trywait((*s_etat_processus).semaphore_fork);
#		endif

#		ifndef SEMAPHORES_NOMMES
		if (pthread_setspecific(semaphore_fork_processus_courant,
				&((*s_etat_processus).semaphore_fork)) != 0)
#		else
		if (pthread_setspecific(semaphore_fork_processus_courant,
				(*s_etat_processus).semaphore_fork) != 0)
#		endif
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}

		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_interruptions_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_nombre_objets_attente[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;
		}

		l_element_courant = (*s_etat_processus).liste_mutexes;
		while(l_element_courant != NULL)
		{
			pthread_mutex_trylock(&((*((struct_mutex *) (*(*l_element_courant)
					.donnee).objet)).mutex));
			pthread_mutex_unlock(&((*((struct_mutex *) (*(*l_element_courant)
					.donnee).objet)).mutex));
			pthread_mutex_destroy(&((*((struct_mutex *) (*(*l_element_courant)
					.donnee).objet)).mutex));

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

		(*(*s_etat_processus).s_liste_variables_partagees)
				.table = NULL;
		(*(*s_etat_processus).s_liste_variables_partagees)
				.nombre_variables = 0;
		(*(*s_etat_processus).s_liste_variables_partagees)
				.nombre_variables_allouees = 0;

		insertion_thread(s_etat_processus, d_vrai);

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

		if (write_atomic(s_etat_processus,
				(*s_argument_thread).pipe_nombre_objets_attente[1],
				"-", sizeof(unsigned char)) != sizeof(unsigned char))
		{
			pthread_mutex_unlock(&((*s_etat_processus).mutex));
			(*s_etat_processus).erreur_systeme = d_es_processus;

			pid_final = -2;

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

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

			exit(EXIT_FAILURE);
		}

		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;

			pid_final = -2;

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

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

			exit(EXIT_FAILURE);
		}

		if (pthread_mutex_unlock(&((*s_etat_processus)
				.protection_liste_mutexes)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;

			pid_final = -2;

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

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

			exit(EXIT_FAILURE);
		}

		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;

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

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

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

		/*
		 * 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.
		 */

		if (sigpending(&set) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else if (sigismember(&set, SIGSTART) == 0)
		{
			while(sigismember(&set, SIGSTART) == 0)
			{
				if (sigpending(&set) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
				}

				nanosleep(&attente, NULL);
			}
		}

		(*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_objets_attente = (*s_argument_thread)
				.pipe_nombre_objets_attente[1];
		(*s_etat_processus).pipe_interruptions = (*s_argument_thread)
				.pipe_interruptions[1];
		(*s_etat_processus).pipe_nombre_interruptions_attente =
				(*s_argument_thread).pipe_nombre_interruptions_attente[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();

		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
		 */

		(*s_etat_processus).l_base_pile_processus = NULL;
		// Les données associées sont déjà effacées par liberation_thread().

		/*
		 * 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)
		{
			pid_final = -2;

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

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

			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)
		{
			pid_final = -2;

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

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

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

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

		(*s_etat_processus).s_connecteurs_sql = NULL;

		/*
		 * 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_fichiers = NULL;

		if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}

		sigpending(&set);

		if ((*s_etat_processus).erreur_systeme == d_es)
		{
			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).var_volatile_alarme == 0)
							&& ((*s_etat_processus).arret_depuis_abort == 0)
							&& ((*s_etat_processus).at_exit != NULL))
					{
						(*s_etat_processus).var_volatile_requete_arret = 0;

						if (evaluation(s_etat_processus,
								(*s_etat_processus).at_exit, 'E') == d_erreur)
						{
							(*s_etat_processus).erreur_execution =
									d_ex_erreur_evaluation;
						}
					}
				}
			}
			else
			{
				if (evaluation(s_etat_processus, s_copie, '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).at_exit != NULL)
					{
						(*s_etat_processus).var_volatile_requete_arret = 0;

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

				liberation(s_etat_processus, s_copie);
			}
		}

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

		l_element_courant = (*s_etat_processus).liste_mutexes;
		while(l_element_courant != NULL)
		{
			pthread_mutex_trylock(&((*((struct_mutex *)
					(*(*l_element_courant).donnee).objet)).mutex));
			pthread_mutex_unlock(&((*((struct_mutex *)
					(*(*l_element_courant).donnee).objet)).mutex));
			pthread_mutex_destroy(&((*((struct_mutex *)
					(*(*l_element_courant).donnee).objet)).mutex));

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

		pid_final = -2;

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

		while((longueur_ecriture = write_atomic(s_etat_processus,
				(*s_argument_thread).pipe_nombre_objets_attente[1],
				&pid_final, sizeof(pid_final))) != sizeof(pid_final))
		{
			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],
					&((*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],
					&((*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;
				}
			}
		}

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

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

		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)
				{
					kill((*(*((struct_processus_fils *)
							(*(*l_element_courant).donnee).objet)).thread).pid,
							SIGURG);
				}
				else
				{
					if ((*s_etat_processus).arret_depuis_abort == -1)
					{
						kill((*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid, SIGFABORT);
					}
					else
					{
						kill((*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid, SIGFSTOP);
					}
				}
			}
			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)
					{
						pthread_kill((*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.tid, SIGURG);
					}
					else
					{
						if ((*s_etat_processus).arret_depuis_abort == -1)
						{
							pthread_kill((*(*((struct_processus_fils *)
									(*(*l_element_courant).donnee).objet))
									.thread).tid, SIGFABORT);
						}
						else
						{
							pthread_kill((*(*((struct_processus_fils *)
									(*(*l_element_courant).donnee).objet))
									.thread).tid, SIGFSTOP);
						}
					}
				}

				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)
		{
			status = 0;

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

					action.sa_handler = SIG_IGN;
					action.sa_flags = SA_ONSTACK;

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

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

						(*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)
					{
						pthread_mutex_unlock(&((*s_etat_processus).mutex));

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

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

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

			nanosleep(&attente, NULL);
			pthread_mutex_lock(&((*s_etat_processus).mutex));
		}

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

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

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

		for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
		{
			liberation(s_etat_processus,
					(*s_etat_processus).s_liste_variables[i].objet);
			free((*s_etat_processus).s_liste_variables[i].nom);
		}

		free((*s_etat_processus).s_liste_variables);

		for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
		{
			liberation(s_etat_processus,
					(*s_etat_processus).s_liste_variables_statiques[i].objet);
			free((*s_etat_processus).s_liste_variables_statiques[i].nom);
		}

		free((*s_etat_processus).s_liste_variables_statiques);

		for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees)
				.nombre_variables; i++)
		{
			liberation(s_etat_processus,
					(*(*s_etat_processus).s_liste_variables_partagees)
					.table[i].objet);
			free((*(*s_etat_processus).s_liste_variables_partagees)
					.table[i].nom);
		}

		if ((*(*s_etat_processus).s_liste_variables_partagees).table
				!= NULL)
		{
			free((struct_variable_partagee *)
					(*(*s_etat_processus).s_liste_variables_partagees).table);
		}

		pthread_mutex_destroy(&((*(*s_etat_processus)
				.s_liste_variables_partagees).mutex));

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

		free((*s_etat_processus).chemin_fichiers_temporaires);

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

#		ifndef Cygwin
		(*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;
		sigaltstack(&((*s_etat_processus).pile_signal), NULL);
		free((*s_etat_processus).pile_signal.ss_sp);
#		endif

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

		closelog();

		liberation_allocateur(s_etat_processus);
		retrait_thread(s_etat_processus);

		pthread_mutex_destroy(&((*s_etat_processus).mutex));
		pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));

		pthread_key_delete(semaphore_fork_processus_courant);

#		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_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
#		endif

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

#		ifndef SEMAPHORES_NOMMES
		sem_destroy(&semaphore_liste_threads);
		sem_post(&semaphore_gestionnaires_signaux);
		sem_destroy(&semaphore_gestionnaires_signaux);
		sem_destroy(&semaphore_gestionnaires_signaux_atomique);
#		else
		sem_destroy2(semaphore_liste_threads, sem_liste_threads);
		sem_post(semaphore_gestionnaires_signaux);
		sem_destroy2(semaphore_gestionnaires_signaux,
				sem_gestionnaires_signaux);
		sem_destroy2(semaphore_gestionnaires_signaux_atomique,
				sem_gestionnaires_signaux_atomique);
#		endif

		clear_history();

		free(s_etat_processus);

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

		exit(EXIT_SUCCESS);
	}
	else
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	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 (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
	{
		(*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)) != 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)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}

					drapeau = d_vrai;
					break;
				}
			}

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

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

	// Être sûr que le processus fils soit déjà présent...

	while(kill((*s_argument_thread).pid, 0) != 0)
	{
		//if ((errno != ESRCH) && (errno != EAGAIN))
		if (errno != ESRCH)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			pthread_mutex_unlock(&((*s_etat_processus).mutex));
			return;
		}

		nanosleep(&attente, NULL);
	}

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

	if (kill((*s_argument_thread).pid, SIGSTART) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		pthread_mutex_unlock(&((*s_etat_processus).mutex));
		return;
	}

	if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		pthread_mutex_unlock(&((*s_etat_processus).mutex));
		return;
	}

	sigpending(&set);

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

	return;
}

// vim: ts=4