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.136 and 1.165

version 1.136, 2013/03/21 11:30:31	version 1.165, 2015/01/27 14:18:09
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	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 = sys_malloc(sizeof(struct_processus))) == NULL)
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
# else
semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);

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

Line 155 rplinit(int argc, char argv[], char en	Line 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;

	initialisation_allocateur_buffer(s_etat_processus);

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

	return(EXIT_FAILURE);
	}

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

if ((langue = getenv("LANG")) != NULL)	if ((langue = getenv("LANG")) != NULL)
Line 200 rplinit(int argc, char argv[], char en	Line 217 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 231 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 260 rplinit(int argc, char argv[], char en	Line 261 rplinit(int argc, char argv[], char en

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

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

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

pthread_mutexattr_init(&attributs_mutex);	pthread_mutexattr_init(&attributs_mutex);
Line 285 rplinit(int argc, char argv[], char en	Line 299 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 325 rplinit(int argc, char argv[], char en	Line 330 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

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

liberation_contexte_cas(s_etat_processus);
liberation_queue_signaux(s_etat_processus);

if (((*s_etat_processus).localisation = malloc((strlen(d_locale)	if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
+ 1) * sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
	# ifndef SEMAPHORES_NOMMES
	sem_post(&((*s_etat_processus).semaphore_fork));
	sem_destroy(&((*s_etat_processus).semaphore_fork));
	# else
	sem_post((*s_etat_processus).semaphore_fork);
	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
	pthread_self(), SEM_FORK);
	# endif

	liberation_contexte_cas(s_etat_processus);
	destruction_queue_signaux(s_etat_processus);

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

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

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

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

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

if (getenv("HOME") != NULL)	if (getenv("HOME") != NULL)
Line 471 rplinit(int argc, char argv[], char en	Line 465 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 518 rplinit(int argc, char argv[], char en	Line 507 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 559 rplinit(int argc, char argv[], char en	Line 543 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

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

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

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

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

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

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 695 rplinit(int argc, char argv[], char en	Line 664 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 733 rplinit(int argc, char argv[], char en	Line 697 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 782 rplinit(int argc, char argv[], char en	Line 741 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 823 rplinit(int argc, char argv[], char en	Line 777 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

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

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

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

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

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

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

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

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

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

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1050 rplinit(int argc, char argv[], char en	Line 979 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 1155 rplinit(int argc, char argv[], char en	Line 1079 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 1708 rplinit(int argc, char argv[], char en	Line 1568 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 1762 rplinit(int argc, char argv[], char en	Line 1617 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 1807 rplinit(int argc, char argv[], char en	Line 1657 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork,
sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
stackoverflow_deinstall_handler();	stackoverflow_deinstall_handler();
Line 3340 rplinit(int argc, char argv[], char en	Line 3031 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 3404 rplinit(int argc, char argv[], char en	Line 3090 rplinit(int argc, char argv[], char en

(*s_etat_processus).liste_mutexes = NULL;	(*s_etat_processus).liste_mutexes = NULL;
(*s_etat_processus).sections_critiques = 0;	(*s_etat_processus).sections_critiques = 0;
	(*s_etat_processus).initialisation_scheduler = d_faux;

(*s_etat_processus).test_instruction = 'N';	(*s_etat_processus).test_instruction = 'N';
(*s_etat_processus).nombre_arguments = 0;	(*s_etat_processus).nombre_arguments = 0;
Line 3606 rplinit(int argc, char argv[], char en	Line 3293 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 3649 rplinit(int argc, char argv[], char en	Line 3331 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 3706 rplinit(int argc, char argv[], char en	Line 3383 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 3796 rplinit(int argc, char argv[], char en	Line 3468 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 3848 rplinit(int argc, char argv[], char en	Line 3515 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 3928 rplinit(int argc, char argv[], char en	Line 3590 rplinit(int argc, char argv[], char en
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_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 3984 rplinit(int argc, char argv[], char en	Line 3641 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 4080 rplinit(int argc, char argv[], char en	Line 3732 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 4140 rplinit(int argc, char argv[], char en	Line 3787 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 4227 rplinit(int argc, char argv[], char en	Line 3869 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 4275 rplinit(int argc, char argv[], char en	Line 3912 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 4324 rplinit(int argc, char argv[], char en	Line 3956 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 4372 rplinit(int argc, char argv[], char en	Line 3999 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 4425 rplinit(int argc, char argv[], char en	Line 4047 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 4483 rplinit(int argc, char argv[], char en	Line 4100 rplinit(int argc, char argv[], char en
{	{
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
encart(s_etat_processus,	encart(s_etat_processus,
(unsigned long) (5 * 1000000));	(integer8) (5 * 1000000));

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
Line 4493 rplinit(int argc, char argv[], char en	Line 4110 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 4563 rplinit(int argc, char argv[], char en	Line 4173 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 4614 rplinit(int argc, char argv[], char en	Line 4217 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 4664 rplinit(int argc, char argv[], char en	Line 4260 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 4730 rplinit(int argc, char argv[], char en	Line 4322 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 4782 rplinit(int argc, char argv[], char en	Line 4367 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 4822 rplinit(int argc, char argv[], char en	Line 4402 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 4875 rplinit(int argc, char argv[], char en	Line 4448 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 4905 rplinit(int argc, char argv[], char en	Line 4473 rplinit(int argc, char argv[], char en
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

	empilement_pile_systeme(s_etat_processus);

if (evaluation(s_etat_processus, s_objet, 'E')	if (evaluation(s_etat_processus, s_objet, 'E')
== d_erreur)	== d_erreur)
{	{
Line 4916 rplinit(int argc, char argv[], char en	Line 4486 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 4975 rplinit(int argc, char argv[], char en	Line 4533 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 5019 rplinit(int argc, char argv[], char en	Line 4570 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 5078 rplinit(int argc, char argv[], char en	Line 4617 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 5139 rplinit(int argc, char argv[], char en	Line 4671 rplinit(int argc, char argv[], char en

if (erreur == d_absence_erreur)	if (erreur == d_absence_erreur)
{	{
if (((*s_etat_processus).var_volatile_alarme	if (((*s_etat_processus)
== 0) && ((*s_etat_processus)
.arret_depuis_abort == 0) &&	.arret_depuis_abort == 0) &&
((*s_etat_processus).at_exit	((*s_etat_processus).at_exit
!= NULL))	!= NULL))
{	{
	// Permet de traiter ATEXIT
	// même après réception d'un SIGINT.
	(*s_etat_processus)
	.var_volatile_alarme = 0;
	(*s_etat_processus)
	.var_volatile_requete_arret = 0;

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

erreur = evaluation(s_etat_processus,	erreur = evaluation(s_etat_processus,
(*s_etat_processus).at_exit,	(*s_etat_processus).at_exit,
'E');	'E');

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

	if (((*s_etat_processus)
	.erreur_execution != d_ex) \|\|
	((*s_etat_processus).exception
	!= d_ep) \|\| ((*s_etat_processus)
	.erreur_systeme != d_es))
	{
	printf("%s [%d]\n", message =
	messages(s_etat_processus),
	(int) getpid());
	free(message);

	if (test_cfsf(s_etat_processus, 51)
	== d_faux)
	{
	printf("%s", ds_beep);
	}

	if ((*s_etat_processus).core ==
	d_vrai)
	{
	printf("\n");

	if ((*s_etat_processus).langue
	== 'F')
	{
	printf("+++Information : Gé"
	"nération du fichie"
	"r rpl-core "
	"[%d]\n", (int)
	getpid());
	}
	else
	{
	printf("+++Information : Wr"
	"iting rpl-core fil"
	"e [%d]\n",
	(int) getpid());
	}

	rplcore(s_etat_processus);

	if ((*s_etat_processus).langue
	== 'F')
	{
	printf("+++Information : Pr"
	"ocessus tracé [%d]"
	"\n",
	(int) getpid());
	}
	else
	{
	printf("+++Information : Do"
	"ne [%d]\n", (int)
	getpid());
	}

	printf("\n");
	fflush(stdout);
	}
	}
}	}
}	}
}	}
Line 5160 rplinit(int argc, char argv[], char en	Line 4772 rplinit(int argc, char argv[], char en

if (erreur == d_absence_erreur)	if (erreur == d_absence_erreur)
{	{
if (((*s_etat_processus).var_volatile_alarme	if (((*s_etat_processus)
== 0) && ((*s_etat_processus)
.arret_depuis_abort == 0) &&	.arret_depuis_abort == 0) &&
((*s_etat_processus).at_exit	((*s_etat_processus).at_exit
!= NULL))	!= NULL))
{	{
	// Permet de traiter ATEXIT
	// même après réception d'un SIGINT.
	(*s_etat_processus)
	.var_volatile_alarme = 0;
	(*s_etat_processus)
	.var_volatile_requete_arret = 0;

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

erreur = evaluation(s_etat_processus,	erreur = evaluation(s_etat_processus,
(*s_etat_processus).at_exit,	(*s_etat_processus).at_exit,
'E');	'E');

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

	if (((*s_etat_processus)
	.erreur_execution != d_ex) \|\|
	((*s_etat_processus).exception
	!= d_ep) \|\| ((*s_etat_processus)
	.erreur_systeme != d_es))
	{
	printf("%s [%d]\n", message =
	messages(s_etat_processus),
	(int) getpid());
	free(message);

	if (test_cfsf(s_etat_processus, 51)
	== d_faux)
	{
	printf("%s", ds_beep);
	}

	if ((*s_etat_processus).core ==
	d_vrai)
	{
	printf("\n");

	if ((*s_etat_processus).langue
	== 'F')
	{
	printf("+++Information : Gé"
	"nération du fichie"
	"r rpl-core "
	"[%d]\n", (int)
	getpid());
	}
	else
	{
	printf("+++Information : Wr"
	"iting rpl-core fil"
	"e [%d]\n",
	(int) getpid());
	}

	rplcore(s_etat_processus);

	if ((*s_etat_processus).langue
	== 'F')
	{
	printf("+++Information : Pr"
	"ocessus tracé [%d]"
	"\n",
	(int) getpid());
	}
	else
	{
	printf("+++Information : Do"
	"ne [%d]\n", (int)
	getpid());
	}

	printf("\n");
	fflush(stdout);
	}
	}
}	}
}	}
}	}
Line 5209 rplinit(int argc, char argv[], char en	Line 4901 rplinit(int argc, char argv[], char en
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}

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

l_element_courant = (void ) (s_etat_processus)	l_element_courant = (void ) (s_etat_processus)
.l_base_pile_processus;	.l_base_pile_processus;
Line 5409 rplinit(int argc, char argv[], char en	Line 5102 rplinit(int argc, char argv[], char en
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus)	sem_post(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
sem_post(
&semaphore_gestionnaires_signaux
);
sem_destroy(
&semaphore_gestionnaires_signaux
);
sem_destroy(&((*s_etat_processus)	sem_destroy(&((*s_etat_processus)
.semaphore_fork));	.semaphore_fork));
# else	# else
sem_post((*s_etat_processus)	sem_post((*s_etat_processus)
.semaphore_fork);	.semaphore_fork);
sem_post(
semaphore_gestionnaires_signaux
);
sem_destroy2(
semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus)	sem_destroy3((*s_etat_processus)
.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 5445 rplinit(int argc, char argv[], char en	Line 5126 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

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

Line 5472 rplinit(int argc, char argv[], char en	Line 5153 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 5508 rplinit(int argc, char argv[], char en	Line 5177 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

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

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

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

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

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

erreur_historique = write_history(	erreur_historique = write_history(
(*s_etat_processus).nom_fichier_historique);	(*s_etat_processus).nom_fichier_historique);
Line 6042 rplinit(int argc, char argv[], char en	Line 5718 rplinit(int argc, char argv[], char en

retrait_thread(s_etat_processus);	retrait_thread(s_etat_processus);

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

Line 6058 rplinit(int argc, char argv[], char en	Line 5736 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 6073 rplinit(int argc, char argv[], char en	Line 5743 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);
free(s_etat_processus);	liberation_etat_processus_readline();
	liberation_allocateur_buffer(s_etat_processus);
	sys_free(s_etat_processus);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
debug_memoire_verification();	debug_memoire_verification();
Line 6206 controle_integrite(struct_processus *s_e	Line 5881 controle_integrite(struct_processus *s_e


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

Line 6221 date_compilation()	Line 5896 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.136
changed lines
	Added in v.1.165