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

void *
lancement_thread(void *argument)
{
	int									status;

	pid_t								ppid;

	sig_atomic_t						registre_stop;

	ssize_t								longueur_ecriture;

	struct_descripteur_thread			*s_argument_thread;

	struct_liste_chainee				*l_element_courant;
	struct_liste_chainee				*l_element_suivant;

	struct_liste_variables_statiques	*l_element_statique_courant;
	struct_liste_variables_statiques	*l_element_statique_suivant;

	struct_objet						*s_objet_temporaire;

	struct_processus					*s_etat_processus;

	struct sigaction					action;
	struct sigaction					registre;

	struct timespec						attente;

	unsigned char						caractere;
	unsigned char						*message;

	unsigned int						erreur;

	integer8							i;

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

	s_argument_thread = (struct_descripteur_thread *) argument;
	s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;

#	ifndef SEMAPHORES_NOMMES
		if (sem_init(&((*s_etat_processus).semaphore_fork), 0, 0) != 0)
#	else
		if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
				pthread_self(), SEM_FORK)) == SEM_FAILED)
#	endif
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		pthread_exit(NULL);
	}

	(*s_argument_thread).tid = pthread_self();
	insertion_thread(s_etat_processus, d_faux);

	if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		pthread_exit(NULL);
	}

	(*s_argument_thread).thread_actif = d_vrai;

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

	// Envoi d'une donnée pour signaler le démarrage du thread 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;

		pthread_mutex_lock(&((*s_argument_thread).mutex));
		pthread_mutex_unlock(&((*s_argument_thread).mutex));

		(*s_argument_thread).thread_actif = d_faux;

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

		pthread_exit(NULL);
	}

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

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

	for((*s_etat_processus).demarrage_fils = d_faux;;)
	{
		scrutation_interruptions(s_etat_processus);

		if ((*s_etat_processus).demarrage_fils == d_vrai)
		{
			break;
		}

		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			pthread_exit(NULL);
		}

		nanosleep(&attente, NULL);

		while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
		{
			if (errno != EINTR)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				pthread_exit(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 thread %llu\n", (int) getpid(),
					(unsigned long long) pthread_self());
		}
		else
		{
			printf("[%d] Start thread %llu\n", (int) getpid(),
					(unsigned long long) pthread_self());
		}

		fflush(stdout);
	}

	(*s_etat_processus).pid_erreur_processus_fils = getpid();

	// Évaluation de l'objet

	if ((*s_etat_processus).erreur_systeme == d_es)
	{
		if (setjmp(contexte_thread) == 0)
		{
			if (evaluation(s_etat_processus, (*s_argument_thread).argument, '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)
					{
						if (((*s_etat_processus).erreur_execution == d_ex) &&
								((*s_etat_processus).erreur_systeme == d_es))
						{
							(*s_etat_processus).erreur_execution =
									d_ex_erreur_evaluation;
						}
					}

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

		if ((*s_argument_thread).destruction_objet == d_vrai)
		{
			liberation(s_etat_processus, (*s_argument_thread).argument);
		}
	}

	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)
	{
		ppid = getpid();

		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;

		if ((*((struct_descripteur_fichier *) (*l_element_courant)
				.donnee)).pid == getpid())
		{
			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)).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 *) (*(*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 *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid);
					}
					else
					{
						printf("[%d] Send stop signal to process %d\n",
								(int) getpid(),
								(int) (*(*((struct_processus_fils *)
								(*(*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 *)
								(*(*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 *)
								(*(*l_element_courant).donnee).objet)).thread)
								.tid);
					}
				}
			}

			if ((*s_etat_processus).var_volatile_alarme != 0)
			{
				if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).mutex))
						!= 0)
				{
					pthread_mutex_unlock(&((*s_etat_processus)
							.mutex_pile_processus));
					(*s_etat_processus).erreur_systeme = d_es_processus;

					pthread_mutex_lock(&((*s_argument_thread).mutex));
					pthread_mutex_unlock(&((*s_argument_thread).mutex));

					(*s_argument_thread).thread_actif = d_faux;

					pthread_exit(NULL);
				}

				if ((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread)
						.thread_actif == d_vrai)
				{
					envoi_signal_thread(NULL,
							(*(*((struct_processus_fils *)
							(*(*l_element_courant).donnee).objet)).thread).tid,
							rpl_sigurg);
				}

				if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread)
						.mutex)) != 0)
				{
					pthread_mutex_unlock(&((*s_etat_processus)
							.mutex_pile_processus));
					(*s_etat_processus).erreur_systeme = d_es_processus;

					pthread_mutex_lock(&((*s_argument_thread).mutex));
					pthread_mutex_unlock(&((*s_argument_thread).mutex));

					(*s_argument_thread).thread_actif = d_faux;

					pthread_exit(NULL);
				}
			}
			else
			{
				if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).mutex))
					   	!= 0)
				{
					pthread_mutex_unlock(&((*s_etat_processus)
							.mutex_pile_processus));
					(*s_etat_processus).erreur_systeme = d_es_processus;

					pthread_mutex_lock(&((*s_argument_thread).mutex));
					pthread_mutex_unlock(&((*s_argument_thread).mutex));

					(*s_argument_thread).thread_actif = d_faux;

					pthread_exit(NULL);
				}

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

				if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
						(*(*l_element_courant).donnee).objet)).thread).mutex))
						!= 0)
				{
					pthread_mutex_unlock(&((*s_etat_processus)
							.mutex_pile_processus));
					(*s_etat_processus).erreur_systeme = d_es_processus;

					pthread_mutex_lock(&((*s_argument_thread).mutex));
					pthread_mutex_unlock(&((*s_argument_thread).mutex));

					(*s_argument_thread).thread_actif = d_faux;

					pthread_exit(NULL);
				}
			}
		}

		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 < (*(*((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)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					pthread_exit(NULL);
				}

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

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

					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;
					pthread_exit(NULL);
				}

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

					(*s_etat_processus).erreur_systeme = d_es_signal;
					pthread_exit(NULL);
				}

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

					(*s_etat_processus).erreur_systeme = d_es_signal;
					pthread_exit(NULL);
				}
			}
		}

		if ((*(*((struct_processus_fils *) (*(*l_element_courant)
				.donnee).objet)).thread).processus_detache == d_vrai)
		{
			if (waitpid((*(*((struct_processus_fils *)
					(*(*l_element_courant).donnee).objet)).thread).pid,
					&status, WNOHANG) < 0)
			{
			}
		}

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

			(*s_etat_processus).erreur_systeme = d_es_processus;
			pthread_exit(NULL);
		}

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

			(*s_etat_processus).erreur_systeme = d_es_processus;
			pthread_exit(NULL);
		}

		pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
		nanosleep(&attente, NULL);
		pthread_mutex_lock(&((*s_etat_processus).mutex_pile_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;

		/*
		 * Fermeture des sockets créées dans le processus courant.
		 */

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

		/*
		 * Fermeture des connecteurs créés dans le processus courant.
		 */

		if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
				.pid == getpid()) && (pthread_equal((*((struct_socket *)
				(*(*l_element_courant).donnee).objet)).tid, pthread_self())
				!= 0))
		{
			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);
		}
	}

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

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

	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(s_etat_processus,
			(*s_etat_processus).s_arbre_variables, d_faux);

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

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

		if (((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid
				== getpid()) && (pthread_equal((*((struct_bibliotheque *)
				(*l_element_courant).donnee)).tid, pthread_self()) != 0))
		{
			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);
	}

	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] Fin du thread %llu\n", (int) getpid(),
					(unsigned long long) pthread_self());
		}
		else
		{
			printf("[%d] End of thread %llu\n", (int) getpid(),
					(unsigned long long) pthread_self());
		}

		fflush(stdout);
	}

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

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

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

	retrait_thread(s_etat_processus);
	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));

#	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

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

	liberation_contexte_cas(s_etat_processus);
	free((*s_etat_processus).localisation);
	liberation_allocateur(s_etat_processus);
	liberation_allocateur_buffer(s_etat_processus);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
	sys_free(s_etat_processus);

	pthread_mutex_lock(&((*s_argument_thread).mutex));
	(*s_argument_thread).thread_actif = d_faux;
	pthread_mutex_unlock(&((*s_argument_thread).mutex));

	pthread_exit(NULL);
}

// vim: ts=4