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.150 and 1.164

version 1.150, 2013/10/04 07:54:50	version 1.164, 2015/01/08 14:29:52
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.16	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2013 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	if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
# else
semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);

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

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

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

if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)	(*s_etat_processus).erreur_systeme = d_es;
{
# ifndef SEMAPHORES_NOMMES	initialisation_allocateur_buffer(s_etat_processus);
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
# endif

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
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 194 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 208 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 276 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)
{	{
# ifndef SEMAPHORES_NOMMES	liberation_contexte_cas(s_etat_processus);
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
# endif

liberation(contexte_cas(s_etat_processus);

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

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

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

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

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

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

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

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

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

erreur = d_es_signal;	erreur = d_es_signal;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 6248 rplinit(int argc, char argv[], char en	Line 5712 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 6263 rplinit(int argc, char argv[], char en	Line 5719 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;
}	}

free(arg_exec);	free(arg_exec);
arret_thread_signaux(s_etat_processus);	arret_thread_signaux(s_etat_processus);
	liberation_allocateur_buffer(s_etat_processus);
free(s_etat_processus);	free(s_etat_processus);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
Line 6411 date_compilation()	Line 5871 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.150
changed lines
	Added in v.1.164