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.155 and 1.162

version 1.155, 2014/04/25 08:18:59	version 1.162, 2015/01/05 13:12:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.18	RPL/2 (R) version 4.1.19
Copyright (C) 1989-2014 Dr. BERTRAND Joël	Copyright (C) 1989-2015 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 128 rplinit(int argc, char argv[], char en	Line 132 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
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;

if ((langue = getenv("LANG")) != NULL)
{
if (strncmp(langue, "fr", 2) == 0)
{
uprintf("+++Système : Mémoire insuffisante\n");
}
else
{
uprintf("+++System : Not enough memory\n");
}
}
else
{
uprintf("+++System : Not enough memory\n");
}

return(EXIT_FAILURE);
}
# endif

if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)	if ((s_etat_processus = malloc(sizeof(struct_processus))) == 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

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 167 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 222 rplinit(int argc, char argv[], char en	Line 181 rplinit(int argc, char argv[], char en

if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)	if ((arg_exec = 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 298 rplinit(int argc, char argv[], char en	Line 249 rplinit(int argc, char argv[], char en
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)
{	{
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
Line 333 rplinit(int argc, char argv[], char en	Line 280 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif
Line 370 rplinit(int argc, char argv[], char en	Line 312 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 409 rplinit(int argc, char argv[], char en	Line 346 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 447 rplinit(int argc, char argv[], char en	Line 379 rplinit(int argc, char argv[], char en

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n");	printf("+++Copyright (C) 1989 à 2014, 2015 BERTRAND Joël\n");
}	}
else	else
{	{
printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");	printf("+++Copyright (C) 1989 to 2014, 2015 BERTRAND Joel\n");
}	}
}	}

Line 483 rplinit(int argc, char argv[], char en	Line 415 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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);

erreur = d_es_signal;	erreur = d_es_signal;

Line 530 rplinit(int argc, char argv[], char en	Line 457 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 571 rplinit(int argc, char argv[], char en	Line 493 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 620 rplinit(int argc, char argv[], char en	Line 537 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 658 rplinit(int argc, char argv[], char en	Line 570 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 707 rplinit(int argc, char argv[], char en	Line 614 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 745 rplinit(int argc, char argv[], char en	Line 647 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 794 rplinit(int argc, char argv[], char en	Line 691 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 835 rplinit(int argc, char argv[], char en	Line 727 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 882 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 923 rplinit(int argc, char argv[], char en	Line 805 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 972 rplinit(int argc, char argv[], char en	Line 849 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 1013 rplinit(int argc, char argv[], char en	Line 885 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 1062 rplinit(int argc, char argv[], char en	Line 929 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_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),	sem_destroy3((*s_etat_processus).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 1167 rplinit(int argc, char argv[], char en	Line 1029 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1211 rplinit(int argc, char argv[], char en	Line 1068 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1258 rplinit(int argc, char argv[], char en	Line 1110 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)
.semaphore_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 1321 rplinit(int argc, char argv[], char en	Line 1166 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)
.semaphore_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 1378 rplinit(int argc, char argv[], char en	Line 1216 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1421 rplinit(int argc, char argv[], char en	Line 1254 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1466 rplinit(int argc, char argv[], char en	Line 1294 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1511 rplinit(int argc, char argv[], char en	Line 1334 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1555 rplinit(int argc, char argv[], char en	Line 1373 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1600 rplinit(int argc, char argv[], char en	Line 1413 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1637 rplinit(int argc, char argv[], char en	Line 1445 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1674 rplinit(int argc, char argv[], char en	Line 1477 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1720 rplinit(int argc, char argv[], char en	Line 1518 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1774 rplinit(int argc, char argv[], char en	Line 1567 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1819 rplinit(int argc, char argv[], char en	Line 1607 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1856 rplinit(int argc, char argv[], char en	Line 1639 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1901 rplinit(int argc, char argv[], char en	Line 1679 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1946 rplinit(int argc, char argv[], char en	Line 1719 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 1991 rplinit(int argc, char argv[], char en	Line 1759 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2028 rplinit(int argc, char argv[], char en	Line 1791 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2076 rplinit(int argc, char argv[], char en	Line 1834 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)
.semaphore_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 2137 rplinit(int argc, char argv[], char en	Line 1888 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)
.semaphore_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 2191 rplinit(int argc, char argv[], char en	Line 1935 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2231 rplinit(int argc, char argv[], char en	Line 1970 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2278 rplinit(int argc, char argv[], char en	Line 2012 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2326 rplinit(int argc, char argv[], char en	Line 2055 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)
.semaphore_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 2387 rplinit(int argc, char argv[], char en	Line 2109 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)
.semaphore_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 2440 rplinit(int argc, char argv[], char en	Line 2155 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2506 rplinit(int argc, char argv[], char en	Line 2216 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)
.semaphore_fork, getpid(),	.semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
Line 2530 rplinit(int argc, char argv[], char en	Line 2228 rplinit(int argc, char argv[], char en

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 2562 rplinit(int argc, char argv[], char en	Line 2260 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2606 rplinit(int argc, char argv[], char en	Line 2299 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2735 rplinit(int argc, char argv[], char en	Line 2423 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2778 rplinit(int argc, char argv[], char en	Line 2461 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2827 rplinit(int argc, char argv[], char en	Line 2505 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2871 rplinit(int argc, char argv[], char en	Line 2544 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2927 rplinit(int argc, char argv[], char en	Line 2595 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 2981 rplinit(int argc, char argv[], char en	Line 2644 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3052 rplinit(int argc, char argv[], char en	Line 2710 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3096 rplinit(int argc, char argv[], char en	Line 2749 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3139 rplinit(int argc, char argv[], char en	Line 2787 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3183 rplinit(int argc, char argv[], char en	Line 2826 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3226 rplinit(int argc, char argv[], char en	Line 2864 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3292 rplinit(int argc, char argv[], char en	Line 2925 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3352 rplinit(int argc, char argv[], char en	Line 2980 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3619 rplinit(int argc, char argv[], char en	Line 3242 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3662 rplinit(int argc, char argv[], char en	Line 3280 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3719 rplinit(int argc, char argv[], char en	Line 3332 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3809 rplinit(int argc, char argv[], char en	Line 3417 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3861 rplinit(int argc, char argv[], char en	Line 3464 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3941 rplinit(int argc, char argv[], char en	Line 3539 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 3997 rplinit(int argc, char argv[], char en	Line 3590 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4093 rplinit(int argc, char argv[], char en	Line 3681 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4153 rplinit(int argc, char argv[], char en	Line 3736 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4240 rplinit(int argc, char argv[], char en	Line 3818 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4288 rplinit(int argc, char argv[], char en	Line 3861 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4337 rplinit(int argc, char argv[], char en	Line 3905 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4385 rplinit(int argc, char argv[], char en	Line 3948 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4438 rplinit(int argc, char argv[], char en	Line 3996 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4506 rplinit(int argc, char argv[], char en	Line 4059 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)
.semaphore_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 4576 rplinit(int argc, char argv[], char en	Line 4122 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)
.semaphore_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 4627 rplinit(int argc, char argv[], char en	Line 4166 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)
.semaphore_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 4677 rplinit(int argc, char argv[], char en	Line 4209 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4743 rplinit(int argc, char argv[], char en	Line 4271 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)
.semaphore_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 4795 rplinit(int argc, char argv[], char en	Line 4316 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4835 rplinit(int argc, char argv[], char en	Line 4351 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)
.semaphore_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 4888 rplinit(int argc, char argv[], char en	Line 4397 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_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semaphore_fork,	sem_destroy3((*s_etat_processus).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 4931 rplinit(int argc, char argv[], char en	Line 4435 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)
.semaphore_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 4990 rplinit(int argc, char argv[], char en	Line 4482 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)
.semaphore_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 5034 rplinit(int argc, char argv[], char en	Line 4519 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)
.semaphore_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 5093 rplinit(int argc, char argv[], char en	Line 4566 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)
.semaphore_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 5585 rplinit(int argc, char argv[], char en	Line 5051 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)
.semaphore_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 5648 rplinit(int argc, char argv[], char en	Line 5102 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)
.semaphore_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 6243 rplinit(int argc, char argv[], char en	Line 5685 rplinit(int argc, char argv[], char en

free((*s_etat_processus).localisation);	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);	destruction_queue_signaux(s_etat_processus);
liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);

Line 6258 rplinit(int argc, char argv[], char en	Line 5692 rplinit(int argc, char argv[], char en

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

Line 6406 date_compilation()	Line 5843 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.155
changed lines
	Added in v.1.162