rpl/src/rpl.c - diff

Return to rpl.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/rpl.c between versions 1.144 and 1.211

version 1.144, 2013/05/23 12:45:08	version 1.211, 2019/02/17 16:08:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.31
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 23	Line 23
#define MAIN_RPL	#define MAIN_RPL
#include "rpl-conv.h"	#include "rpl-conv.h"

	// Bug de gcc à partir de gcc 4.6 (bug 48544)
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wclobbered"


/*	/*
================================================================================	================================================================================
Line 82 rplinit(int argc, char argv[], char en	Line 86 rplinit(int argc, char argv[], char en

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

	struct_liste_chainee *l_bibliotheques;
	struct_liste_chainee *l_bibliotheque_courante;
	struct_liste_chainee *l_nouvelle_bibliotheque;

struct_liste_variables_partagees *l_element_partage_courant;	struct_liste_variables_partagees *l_element_partage_courant;
struct_liste_variables_partagees *l_element_partage_suivant;	struct_liste_variables_partagees *l_element_partage_suivant;

Line 119 rplinit(int argc, char argv[], char en	Line 127 rplinit(int argc, char argv[], char en
errno = 0;	errno = 0;
s_queue_signaux = NULL;	s_queue_signaux = NULL;
routine_recursive = 0;	routine_recursive = 0;
	nombre_threads_surveillance_processus = 0;
pid_processus_pere = getpid();	pid_processus_pere = getpid();

	# ifdef DEBUG_PROC
	__proc = 0;
	# endif

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
debug_memoire_initialisation();	debug_memoire_initialisation();
# endif	# endif
Line 128 rplinit(int argc, char argv[], char en	Line 141 rplinit(int argc, char argv[], char en
setvbuf(stdout, NULL, _IOLBF, 0);	setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);	setvbuf(stderr, NULL, _IOLBF, 0);

# ifndef SEMAPHORES_NOMMES	if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL)
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
# else
semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);

if (semaphore_gestionnaires_signaux == SEM_FAILED)
{	{
erreur = d_es_allocation_memoire;	erreur = d_es_allocation_memoire;

Line 155 rplinit(int argc, char argv[], char en	Line 163 rplinit(int argc, char argv[], char en

return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}
# endif

if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)	(*s_etat_processus).erreur_systeme = d_es;

	initialisation_allocateur_buffer(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
# ifndef SEMAPHORES_NOMMES	erreur = d_es_allocation_memoire;
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);	if ((langue = getenv("LANG")) != NULL)
# else	{
sem_post(semaphore_gestionnaires_signaux);	if (strncmp(langue, "fr", 2) == 0)
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);	{
# endif	uprintf("+++Système : Mémoire insuffisante\n");
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}

	return(EXIT_FAILURE);
	}

	if (initialisation_etat_processus_readline() != 0)
	{
erreur = d_es_allocation_memoire;	erreur = d_es_allocation_memoire;

if ((langue = getenv("LANG")) != NULL)	if ((langue = getenv("LANG")) != NULL)
Line 200 rplinit(int argc, char argv[], char en	Line 226 rplinit(int argc, char argv[], char en

if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)	if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
{	{
# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
# endif

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
uprintf("+++Système : Mémoire insuffisante\n");	uprintf("+++Système : Mémoire insuffisante\n");
Line 220 rplinit(int argc, char argv[], char en	Line 238 rplinit(int argc, char argv[], char en
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)	if ((arg_exec = sys_malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)
{	{
# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
# endif

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
uprintf("+++Système : Mémoire insuffisante\n");	uprintf("+++Système : Mémoire insuffisante\n");
Line 247 rplinit(int argc, char argv[], char en	Line 257 rplinit(int argc, char argv[], char en
arg_exec[i] = argv[i];	arg_exec[i] = argv[i];
}	}

argv[argc] = NULL;	arg_exec[argc] = NULL;

initialisation_contexte_cas(s_etat_processus);	initialisation_contexte_cas(s_etat_processus);

Line 260 rplinit(int argc, char argv[], char en	Line 270 rplinit(int argc, char argv[], char en

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

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

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

pthread_mutexattr_init(&attributs_mutex);	pthread_mutexattr_init(&attributs_mutex);
Line 270 rplinit(int argc, char argv[], char en	Line 293 rplinit(int argc, char argv[], char en
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

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

	pthread_mutexattr_init(&attributs_mutex);
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);
Line 279 rplinit(int argc, char argv[], char en	Line 308 rplinit(int argc, char argv[], char en
pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);	pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

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

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

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
# else	# else
if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),	if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
pthread_self(), SEM_FORK)) == SEM_FAILED)	pthread_self(), SEM_FORK)) == SEM_FAILED)
{	{
# ifndef SEMAPHORES_NOMMES	liberation_contexte_cas(s_etat_processus);
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
# endif

liberation(contexte_cas(s_etat_processus);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 325 rplinit(int argc, char argv[], char en	Line 355 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 357 rplinit(int argc, char argv[], char en	Line 382 rplinit(int argc, char argv[], char en
}	}
else	else
{	{
# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));
# else
sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);
# endif

liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);

if (((*s_etat_processus).localisation = malloc((strlen(d_locale)	if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
+ 1) * sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
uprintf("+++Système : Mémoire insuffisante\n");	uprintf("+++Système : Mémoire insuffisante\n");
Line 401 rplinit(int argc, char argv[], char en	Line 421 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 431 rplinit(int argc, char argv[], char en	Line 446 rplinit(int argc, char argv[], char en
strcpy((*s_etat_processus).localisation, d_locale);	strcpy((*s_etat_processus).localisation, d_locale);
}	}

printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,	if (resultats == NULL) // Appel direct
((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);

if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Copyright (C) 1989 à 2012, 2013 BERTRAND Joël\n");	printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
}	((*s_etat_processus).langue == 'F')
else	? d_date_rpl : d_date_en_rpl);
{
printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n");	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Copyright (C) 1989 à 2018, 2019 BERTRAND Joël\n");
	}
	else
	{
	printf("+++Copyright (C) 1989 to 2018, 2019 BERTRAND Joel\n");
	}
}	}

if (getenv("HOME") != NULL)	if (getenv("HOME") != NULL)
Line 471 rplinit(int argc, char argv[], char en	Line 490 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

erreur = d_es_signal;	erreur = d_es_signal;

Line 514 rplinit(int argc, char argv[], char en	Line 528 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
{
# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));
# else
sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);
# endif

liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();
# endif

erreur = d_es_signal;

if ((*s_etat_processus).langue == 'F')
{
printf("+++Système : Initialisation des signaux POSIX "
"impossible\n");
}
else
{
printf("+++System : Initialization of POSIX signals failed\n");
}

return(EXIT_FAILURE);
}

action.sa_handler = interruption1;	action.sa_handler = interruption1;
action.sa_flags = 0;	action.sa_flags = 0;

Line 559 rplinit(int argc, char argv[], char en	Line 535 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 608 rplinit(int argc, char argv[], char en	Line 579 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 646 rplinit(int argc, char argv[], char en	Line 612 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 695 rplinit(int argc, char argv[], char en	Line 656 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 729 rplinit(int argc, char argv[], char en	Line 685 rplinit(int argc, char argv[], char en
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

if (sigaction(SIGALRM, &action, NULL) != 0)	if (sigaction(SIGUSR2, &action, NULL) != 0)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 768 rplinit(int argc, char argv[], char en	Line 719 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
raise(SIGALRM);	raise(SIGUSR2);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 778 rplinit(int argc, char argv[], char en	Line 729 rplinit(int argc, char argv[], char en
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
}	}

if (signal_test != SIGALRM)	if (signal_test != SIGUSR2)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 823 rplinit(int argc, char argv[], char en	Line 769 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 870 rplinit(int argc, char argv[], char en	Line 811 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 911 rplinit(int argc, char argv[], char en	Line 847 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 960 rplinit(int argc, char argv[], char en	Line 891 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1001 rplinit(int argc, char argv[], char en	Line 927 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1050 rplinit(int argc, char argv[], char en	Line 971 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1097 rplinit(int argc, char argv[], char en	Line 1013 rplinit(int argc, char argv[], char en
drapeau_encart = 'Y';	drapeau_encart = 'Y';
debug = d_faux;	debug = d_faux;
arguments = NULL;	arguments = NULL;
	l_bibliotheques = NULL;

(*s_etat_processus).s_fichiers = NULL;	(*s_etat_processus).s_fichiers = NULL;
(*s_etat_processus).s_sockets = NULL;	(*s_etat_processus).s_sockets = NULL;
Line 1155 rplinit(int argc, char argv[], char en	Line 1072 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1199 rplinit(int argc, char argv[], char en	Line 1111 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1246 rplinit(int argc, char argv[], char en	Line 1153 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1309 rplinit(int argc, char argv[], char en	Line 1209 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1366 rplinit(int argc, char argv[], char en	Line 1259 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1409 rplinit(int argc, char argv[], char en	Line 1297 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1454 rplinit(int argc, char argv[], char en	Line 1337 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1499 rplinit(int argc, char argv[], char en	Line 1377 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1543 rplinit(int argc, char argv[], char en	Line 1416 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1588 rplinit(int argc, char argv[], char en	Line 1456 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1625 rplinit(int argc, char argv[], char en	Line 1488 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1662 rplinit(int argc, char argv[], char en	Line 1520 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1708 rplinit(int argc, char argv[], char en	Line 1561 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1756 rplinit(int argc, char argv[], char en	Line 1604 rplinit(int argc, char argv[], char en
break;	break;
}	}

	case 'm' :
	{
	while(*(++argv[0]) == ' ');
	argv[0]--;

	if ((*(++argv[0])) != '\0')
	{
	if ((l_nouvelle_bibliotheque = malloc(
	sizeof(struct_liste_chainee))) == NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	(*l_nouvelle_bibliotheque).suivant =
	l_bibliotheques;

	if (((*l_nouvelle_bibliotheque).donnee =
	allocation(s_etat_processus, CHN))
	== NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	if ((((l_nouvelle_bibliotheque).donnee)
	.objet = malloc((strlen(argv[0]) + 1) *
	sizeof(unsigned char))) == NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	strcpy(((l_nouvelle_bibliotheque).donnee)
	.objet, argv[0]);
	argv[0] += strlen((unsigned char *)
	((l_nouvelle_bibliotheque).donnee)
	.objet) - 1;

	l_bibliotheques = l_nouvelle_bibliotheque;
	}
	else if ((--argc) > 0)
	{
	argv++;

	if ((l_nouvelle_bibliotheque = malloc(
	sizeof(struct_liste_chainee))) == NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	(*l_nouvelle_bibliotheque).suivant =
	l_bibliotheques;

	if (((*l_nouvelle_bibliotheque).donnee =
	allocation(s_etat_processus, CHN))
	== NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	if ((((l_nouvelle_bibliotheque).donnee)
	.objet = malloc((strlen(argv[0]) + 1) *
	sizeof(unsigned char))) == NULL)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Mémoire "
	"insuffisante\n");
	}
	else
	{
	printf("+++System : Not enough "
	"memory\n");
	}

	return(EXIT_FAILURE);
	}

	strcpy(((l_nouvelle_bibliotheque).donnee)
	.objet, argv[0]);
	argv[0] += strlen((unsigned char *)
	((l_nouvelle_bibliotheque).donnee)
	.objet) - 1;

	l_bibliotheques = l_nouvelle_bibliotheque;
	}
	else
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Erreur : Aucune bibliothèque "
	"spécifiée après l'option -A\n");
	}
	else
	{
	printf("+++Error : Library required after "
	"-m option\n");
	}

	return(EXIT_FAILURE);
	}

	break;
	}

case 'n' :	case 'n' :
{	{
if (option_n == d_vrai)	if (option_n == d_vrai)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1807 rplinit(int argc, char argv[], char en	Line 1945 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1844 rplinit(int argc, char argv[], char en	Line 1977 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1889 rplinit(int argc, char argv[], char en	Line 2017 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1934 rplinit(int argc, char argv[], char en	Line 2057 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1979 rplinit(int argc, char argv[], char en	Line 2097 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2016 rplinit(int argc, char argv[], char en	Line 2129 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2064 rplinit(int argc, char argv[], char en	Line 2172 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2125 rplinit(int argc, char argv[], char en	Line 2226 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2179 rplinit(int argc, char argv[], char en	Line 2273 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2214 rplinit(int argc, char argv[], char en	Line 2303 rplinit(int argc, char argv[], char en
}	}

if (((*s_etat_processus).definitions_chainees =	if (((*s_etat_processus).definitions_chainees =
compactage((*s_etat_processus)	compactage(s_etat_processus,
.definitions_chainees)) == NULL)	(*s_etat_processus).definitions_chainees))
	== NULL)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2266 rplinit(int argc, char argv[], char en	Line 2351 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2314 rplinit(int argc, char argv[], char en	Line 2394 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2375 rplinit(int argc, char argv[], char en	Line 2448 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2428 rplinit(int argc, char argv[], char en	Line 2494 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2494 rplinit(int argc, char argv[], char en	Line 2555 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(	liberation_contexte_cas(
s_etat_processus);	s_etat_processus);
liberation_queue_signaux(	destruction_queue_signaux(
s_etat_processus);	s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
Line 2550 rplinit(int argc, char argv[], char en	Line 2599 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2594 rplinit(int argc, char argv[], char en	Line 2638 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2723 rplinit(int argc, char argv[], char en	Line 2762 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2766 rplinit(int argc, char argv[], char en	Line 2800 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2815 rplinit(int argc, char argv[], char en	Line 2844 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2859 rplinit(int argc, char argv[], char en	Line 2883 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2915 rplinit(int argc, char argv[], char en	Line 2934 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 2969 rplinit(int argc, char argv[], char en	Line 2983 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3040 rplinit(int argc, char argv[], char en	Line 3049 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3084 rplinit(int argc, char argv[], char en	Line 3088 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3127 rplinit(int argc, char argv[], char en	Line 3126 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3171 rplinit(int argc, char argv[], char en	Line 3165 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3214 rplinit(int argc, char argv[], char en	Line 3203 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3280 rplinit(int argc, char argv[], char en	Line 3264 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3340 rplinit(int argc, char argv[], char en	Line 3319 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3607 rplinit(int argc, char argv[], char en	Line 3581 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3650 rplinit(int argc, char argv[], char en	Line 3619 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3707 rplinit(int argc, char argv[], char en	Line 3671 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3797 rplinit(int argc, char argv[], char en	Line 3756 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3849 rplinit(int argc, char argv[], char en	Line 3803 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3929 rplinit(int argc, char argv[], char en	Line 3878 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3985 rplinit(int argc, char argv[], char en	Line 3929 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4081 rplinit(int argc, char argv[], char en	Line 4020 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4136 rplinit(int argc, char argv[], char en	Line 4070 rplinit(int argc, char argv[], char en
}	}
}	}

	/*
	* Chargement des bibliothèques pour gérer des
	* types externes lors des l'analyse syntaxique et
	* compilation.
	*/

	l_bibliotheque_courante = l_bibliotheques;

	while(l_bibliotheque_courante != NULL)
	{
	if (empilement(s_etat_processus, &((*s_etat_processus)
	.l_base_pile), (*l_bibliotheque_courante)
	.donnee) == d_erreur)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	# ifdef HAVE_SIGSEGV_RECOVERY
	if (debug == d_faux)
	{
	sigsegv_deinstall_handler();
	}
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Fatal :"
	" Chargement de la bibliothèse %s"
	" impossible\n", (unsigned char *)
	((l_bibliotheque_courante).donnee)
	.objet);
	}
	else
	{
	printf("+++Fatal : Cannot load library %s\n",
	((l_bibliotheque_courante).donnee)
	.objet);
	}

	if (traitement_fichier_temporaire == 'Y')
	{
	if (destruction_fichier(
	nom_fichier_temporaire)
	== d_erreur)
	{
	return(EXIT_FAILURE);
	}

	free(nom_fichier_temporaire);
	}

	return(EXIT_FAILURE);
	}

	instruction_use(s_etat_processus);

	if (depilement(s_etat_processus, &((*s_etat_processus)
	.l_base_pile), &((*l_bibliotheque_courante)
	.donnee)) == d_erreur)
	{
	# 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

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
	stackoverflow_deinstall_handler();
	# endif

	# ifdef HAVE_SIGSEGV_RECOVERY
	if (debug == d_faux)
	{
	sigsegv_deinstall_handler();
	}
	# endif

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Fatal :"
	" Chargement de la bibliothèse %s"
	" impossible\n", (unsigned char *)
	((l_bibliotheque_courante).donnee)
	.objet);
	}
	else
	{
	printf("+++Fatal : Cannot load library %s\n",
	((l_bibliotheque_courante).donnee)
	.objet);
	}

	if (traitement_fichier_temporaire == 'Y')
	{
	if (destruction_fichier(
	nom_fichier_temporaire)
	== d_erreur)
	{
	return(EXIT_FAILURE);
	}

	free(nom_fichier_temporaire);
	}

	return(EXIT_FAILURE);
	}

	l_bibliotheque_courante =
	(*l_bibliotheque_courante).suivant;
	}

if ((erreur = compilation(s_etat_processus)) !=	if ((erreur = compilation(s_etat_processus)) !=
d_absence_erreur)	d_absence_erreur)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4228 rplinit(int argc, char argv[], char en	Line 4289 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4276 rplinit(int argc, char argv[], char en	Line 4332 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4325 rplinit(int argc, char argv[], char en	Line 4376 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4373 rplinit(int argc, char argv[], char en	Line 4419 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4426 rplinit(int argc, char argv[], char en	Line 4467 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4494 rplinit(int argc, char argv[], char en	Line 4530 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4564 rplinit(int argc, char argv[], char en	Line 4593 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4615 rplinit(int argc, char argv[], char en	Line 4637 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4665 rplinit(int argc, char argv[], char en	Line 4680 rplinit(int argc, char argv[], char en
(*s_etat_processus).definitions_chainees = tampon;	(*s_etat_processus).definitions_chainees = tampon;
(*s_etat_processus).position_courante = 0;	(*s_etat_processus).position_courante = 0;

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4731 rplinit(int argc, char argv[], char en	Line 4742 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4783 rplinit(int argc, char argv[], char en	Line 4787 rplinit(int argc, char argv[], char en

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

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4823 rplinit(int argc, char argv[], char en	Line 4822 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4876 rplinit(int argc, char argv[], char en	Line 4868 rplinit(int argc, char argv[], char en

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

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4919 rplinit(int argc, char argv[], char en	Line 4906 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 4978 rplinit(int argc, char argv[], char en	Line 4953 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 5022 rplinit(int argc, char argv[], char en	Line 4990 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 5081 rplinit(int argc, char argv[], char en	Line 5037 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(
&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork,	.semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 5239 rplinit(int argc, char argv[], char en	Line 5188 rplinit(int argc, char argv[], char en
{	{
if (setjmp(contexte_initial) == 0)	if (setjmp(contexte_initial) == 0)
{	{
erreur = sequenceur_optimise(s_etat_processus);	erreur = sequenceur_optimise(s_etat_processus,
	l_bibliotheques);

if (erreur == d_absence_erreur)	if (erreur == d_absence_erreur)
{	{
Line 5372 rplinit(int argc, char argv[], char en	Line 5322 rplinit(int argc, char argv[], char en
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}

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

l_element_courant = (void ) (s_etat_processus)	l_element_courant = (void ) (s_etat_processus)
.l_base_pile_processus;	.l_base_pile_processus;
Line 5449 rplinit(int argc, char argv[], char en	Line 5400 rplinit(int argc, char argv[], char en
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, rpl_sigurg);	.thread).pid, rpl_sigurg, d_faux);
}	}
else	else
{	{
Line 5460 rplinit(int argc, char argv[], char en	Line 5411 rplinit(int argc, char argv[], char en
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, rpl_sigabort);	.thread).pid, rpl_sigabort, d_faux);
}	}
else	else
{	{
Line 5468 rplinit(int argc, char argv[], char en	Line 5419 rplinit(int argc, char argv[], char en
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, rpl_sigstop);	.thread).pid, rpl_sigstop, d_faux);
}	}
}	}
}	}
Line 5487 rplinit(int argc, char argv[], char en	Line 5438 rplinit(int argc, char argv[], char en
if ((*s_etat_processus).var_volatile_alarme	if ((*s_etat_processus).var_volatile_alarme
!= 0)	!= 0)
{	{
envoi_signal_thread(	envoi_signal_thread(s_etat_processus,
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
Line 5498 rplinit(int argc, char argv[], char en	Line 5449 rplinit(int argc, char argv[], char en
if ((*s_etat_processus).arret_depuis_abort	if ((*s_etat_processus).arret_depuis_abort
== -1)	== -1)
{	{
envoi_signal_thread(	envoi_signal_thread(s_etat_processus,
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee)	l_element_courant)).donnee)
Line 5507 rplinit(int argc, char argv[], char en	Line 5458 rplinit(int argc, char argv[], char en
}	}
else	else
{	{
envoi_signal_thread(	envoi_signal_thread(s_etat_processus,
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee)	l_element_courant)).donnee)
Line 5572 rplinit(int argc, char argv[], char en	Line 5523 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 5608 rplinit(int argc, char argv[], char en	Line 5547 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

pthread_mutex_unlock(	pthread_mutex_unlock(&((*s_etat_processus)
&((*s_etat_processus).mutex));	.mutex_pile_processus));
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

Line 5635 rplinit(int argc, char argv[], char en	Line 5574 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.semphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 5671 rplinit(int argc, char argv[], char en	Line 5598 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

pthread_mutex_unlock(	pthread_mutex_unlock(&((*s_etat_processus)
&((*s_etat_processus).mutex));	.mutex_pile_processus));
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}
}	}
}	}

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

if ((*s_etat_processus)	if ((*s_etat_processus)
.nombre_interruptions_non_affectees != 0)	.nombre_interruptions_non_affectees != 0)
{	{
Line 5685 rplinit(int argc, char argv[], char en	Line 5615 rplinit(int argc, char argv[], char en
s_etat_processus);	s_etat_processus);
}	}

pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_interruptions));
	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
scrutation_interruptions(s_etat_processus);	scrutation_interruptions(s_etat_processus);
pthread_mutex_lock(&((*s_etat_processus).mutex));	pthread_mutex_lock(&((*s_etat_processus)
	.mutex_pile_processus));
}	}

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

erreur_historique = write_history(	erreur_historique = write_history(
(*s_etat_processus).nom_fichier_historique);	(*s_etat_processus).nom_fichier_historique);
Line 5881 rplinit(int argc, char argv[], char en	Line 5816 rplinit(int argc, char argv[], char en
{	{
if ((*resultats) != NULL)	if ((*resultats) != NULL)
{	{
free((*resultats));	sys_free((*resultats));

if (((*resultats) = malloc(((size_t)	if (((*resultats) = sys_malloc(((size_t)
((*s_etat_processus)	((*s_etat_processus)
.hauteur_pile_operationnelle + 1))	.hauteur_pile_operationnelle + 1))
* sizeof(unsigned char **))) != NULL)	* sizeof(unsigned char **))) != NULL)
Line 5970 rplinit(int argc, char argv[], char en	Line 5905 rplinit(int argc, char argv[], char en
l_element_courant = l_element_suivant;	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 = (void ) (s_etat_processus)
.s_bibliotheques;

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

free((((struct_bibliotheque )
(((struct_liste_chainee )
l_element_courant)).donnee)).nom);
dlclose((((struct_bibliotheque )
(((struct_liste_chainee )
l_element_courant)).donnee)).descripteur);
free((((struct_liste_chainee ) l_element_courant))
.donnee);
free(l_element_courant);

l_element_courant = l_element_suivant;
}

l_element_courant = (void ) (s_etat_processus)	l_element_courant = (void ) (s_etat_processus)
.l_base_pile_last;	.l_base_pile_last;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 6020 rplinit(int argc, char argv[], char en	Line 5920 rplinit(int argc, char argv[], char en
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

	while((*s_etat_processus).s_bibliotheques != NULL)
	{
	retrait_bibliotheque(s_etat_processus,
	(struct_bibliotheque *)
	(((struct_liste_chainee )
	(*s_etat_processus).s_bibliotheques)).donnee);
	}

l_element_courant = (void ) (s_etat_processus)	l_element_courant = (void ) (s_etat_processus)
.l_base_pile_systeme;	.l_base_pile_systeme;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 6204 rplinit(int argc, char argv[], char en	Line 6112 rplinit(int argc, char argv[], char en

retrait_thread(s_etat_processus);	retrait_thread(s_etat_processus);

pthread_mutex_destroy(&((*s_etat_processus).mutex));	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

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

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

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

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

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

	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
	pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
pthread_mutex_destroy(&mutex_sections_critiques);	pthread_mutex_destroy(&mutex_sections_critiques);
pthread_mutex_destroy(&mutex_liste_variables_partagees);	pthread_mutex_destroy(&mutex_liste_variables_partagees);

	free((*s_etat_processus).localisation);

	destruction_queue_signaux(s_etat_processus);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
	liberation_contexte_cas(s_etat_processus);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
Line 6218 rplinit(int argc, char argv[], char en	Line 6159 rplinit(int argc, char argv[], char en
SEM_FORK);	SEM_FORK);
# endif	# endif

free((*s_etat_processus).localisation);

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
# endif

destruction_queue_signaux(s_etat_processus);
liberation_contexte_cas(s_etat_processus);

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

if ((*s_etat_processus).requete_redemarrage == d_vrai)	if ((*s_etat_processus).requete_redemarrage == d_vrai)
{	{
chdir(repertoire_initial);	if (chdir(repertoire_initial) == 0)
execvp(arg_exec[0], &(arg_exec[0]));	{
	execvp(arg_exec[0], &(arg_exec[0]));
	}

erreur = d_erreur;	erreur = d_erreur;
}	}

free(arg_exec);	liberation_etat_processus_readline();
arret_thread_signaux(s_etat_processus);
free(s_etat_processus);	liberation_allocateur_buffer(s_etat_processus);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
	pthread_mutex_destroy(&mutex_liste_threads);
	pthread_mutex_destroy(&mutex_sigaction);

	sys_free(s_etat_processus);
	sys_free(arg_exec);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
debug_memoire_verification();	debug_memoire_verification();
Line 6281 informations(struct_processus *s_etat_pr	Line 6218 informations(struct_processus *s_etat_pr
printf(" -i : fonctionnement interactif\n");	printf(" -i : fonctionnement interactif\n");
printf(" -l : licence d'utilisation\n");	printf(" -l : licence d'utilisation\n");
printf(" -n : ignorance du signal HUP\n");	printf(" -n : ignorance du signal HUP\n");
	printf(" -m : chargement d'un module RPL/SO avant la "
	"compilation\n");
printf(" -p : précompilation du script avant exécution\n");	printf(" -p : précompilation du script avant exécution\n");
printf(" -P : profilage (-P ou -PP)\n");	printf(" -P : profilage (-P ou -PP)\n");
printf(" -s : empêchement de l'ouverture de l'écran initial\n");	printf(" -s : empêchement de l'ouverture de l'écran initial\n");
Line 6302 informations(struct_processus *s_etat_pr	Line 6241 informations(struct_processus *s_etat_pr
printf(" -i : runs the RPL/2 sequencer in interactive mode\n");	printf(" -i : runs the RPL/2 sequencer in interactive mode\n");
printf(" -l : prints the user licence of the software\n");	printf(" -l : prints the user licence of the software\n");
printf(" -n : ignores HUP signal\n");	printf(" -n : ignores HUP signal\n");
	printf(" -m : loads RPL/SO object before compilation\n");
printf(" -p : precompiles script\n");	printf(" -p : precompiles script\n");
printf(" -P : computes profile data (-P or -PP)\n");	printf(" -P : computes profile data (-P or -PP)\n");
printf(" -s : disables splash screen\n");	printf(" -s : disables splash screen\n");
Line 6368 controle_integrite(struct_processus *s_e	Line 6308 controle_integrite(struct_processus *s_e


unsigned char *	unsigned char *
date_compilation()	date_compilation(struct_processus *s_etat_processus)
{	{
unsigned char *date;	unsigned char *date;

Line 6383 date_compilation()	Line 6323 date_compilation()
return(date);	return(date);
}	}

	#pragma GCC diagnostic pop

// vim: ts=4	// vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.144
changed lines
	Added in v.1.211