rpl/src/rpl.c - diff

Return to rpl.c CVS log

Up to [local] / rpl / src

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

version 1.144, 2013/05/23 12:45:08	version 1.157, 2014/05/17 15:35:51
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.18
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2014 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 260 rplinit(int argc, char argv[], char en	Line 264 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 302 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	sem_post(semaphore_gestionnaires_signaux);
sem_post(&semaphore_gestionnaires_signaux);	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
sem_destroy(&semaphore_gestionnaires_signaux);	SEM_SIGNAUX);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);
# endif

liberation(contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 333 rplinit(int argc, char argv[], char en	Line 345 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 357 rplinit(int argc, char argv[], char en	Line 369 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_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).semaphore_fork, getpid(),
	pthread_self(), SEM_FORK);
	# endif

	liberation_contexte_cas(s_etat_processus);
	liberation_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 409 rplinit(int argc, char argv[], char en	Line 421 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 431 rplinit(int argc, char argv[], char en	Line 443 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 à 2013, 2014 BERTRAND Joël\n");
	}
	else
	{
	printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");
	}
}	}

if (getenv("HOME") != NULL)	if (getenv("HOME") != NULL)
Line 479 rplinit(int argc, char argv[], char en	Line 495 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 526 rplinit(int argc, char argv[], char en	Line 542 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 567 rplinit(int argc, char argv[], char en	Line 583 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 616 rplinit(int argc, char argv[], char en	Line 632 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 654 rplinit(int argc, char argv[], char en	Line 670 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 703 rplinit(int argc, char argv[], char en	Line 719 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 741 rplinit(int argc, char argv[], char en	Line 757 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 790 rplinit(int argc, char argv[], char en	Line 806 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 831 rplinit(int argc, char argv[], char en	Line 847 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 878 rplinit(int argc, char argv[], char en	Line 894 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 919 rplinit(int argc, char argv[], char en	Line 935 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 968 rplinit(int argc, char argv[], char en	Line 984 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 1009 rplinit(int argc, char argv[], char en	Line 1025 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 1058 rplinit(int argc, char argv[], char en	Line 1074 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, getpid(),	sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
SEM_SIGNAUX);	SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork, getpid(),	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

Line 1164 rplinit(int argc, char argv[], char en	Line 1180 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1208 rplinit(int argc, char argv[], char en	Line 1224 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1259 rplinit(int argc, char argv[], char en	Line 1275 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 1322 rplinit(int argc, char argv[], char en	Line 1338 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 1375 rplinit(int argc, char argv[], char en	Line 1391 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1418 rplinit(int argc, char argv[], char en	Line 1434 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1463 rplinit(int argc, char argv[], char en	Line 1479 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1508 rplinit(int argc, char argv[], char en	Line 1524 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1552 rplinit(int argc, char argv[], char en	Line 1568 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1597 rplinit(int argc, char argv[], char en	Line 1613 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1634 rplinit(int argc, char argv[], char en	Line 1650 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1671 rplinit(int argc, char argv[], char en	Line 1687 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1717 rplinit(int argc, char argv[], char en	Line 1733 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1771 rplinit(int argc, char argv[], char en	Line 1787 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1816 rplinit(int argc, char argv[], char en	Line 1832 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1853 rplinit(int argc, char argv[], char en	Line 1869 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1898 rplinit(int argc, char argv[], char en	Line 1914 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1943 rplinit(int argc, char argv[], char en	Line 1959 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 1988 rplinit(int argc, char argv[], char en	Line 2004 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2025 rplinit(int argc, char argv[], char en	Line 2041 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2077 rplinit(int argc, char argv[], char en	Line 2093 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 2138 rplinit(int argc, char argv[], char en	Line 2154 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 2188 rplinit(int argc, char argv[], char en	Line 2204 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2228 rplinit(int argc, char argv[], char en	Line 2244 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2275 rplinit(int argc, char argv[], char en	Line 2291 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2327 rplinit(int argc, char argv[], char en	Line 2343 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 2388 rplinit(int argc, char argv[], char en	Line 2404 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 2437 rplinit(int argc, char argv[], char en	Line 2453 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2512 rplinit(int argc, char argv[], char en	Line 2528 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 2559 rplinit(int argc, char argv[], char en	Line 2575 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2603 rplinit(int argc, char argv[], char en	Line 2619 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2732 rplinit(int argc, char argv[], char en	Line 2748 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2775 rplinit(int argc, char argv[], char en	Line 2791 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2824 rplinit(int argc, char argv[], char en	Line 2840 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2868 rplinit(int argc, char argv[], char en	Line 2884 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2924 rplinit(int argc, char argv[], char en	Line 2940 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 2978 rplinit(int argc, char argv[], char en	Line 2994 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3049 rplinit(int argc, char argv[], char en	Line 3065 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3093 rplinit(int argc, char argv[], char en	Line 3109 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3136 rplinit(int argc, char argv[], char en	Line 3152 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3180 rplinit(int argc, char argv[], char en	Line 3196 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3223 rplinit(int argc, char argv[], char en	Line 3239 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3288 rplinit(int argc, char argv[], char en	Line 3304 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3348 rplinit(int argc, char argv[], char en	Line 3364 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3615 rplinit(int argc, char argv[], char en	Line 3631 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3658 rplinit(int argc, char argv[], char en	Line 3674 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3715 rplinit(int argc, char argv[], char en	Line 3731 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3805 rplinit(int argc, char argv[], char en	Line 3821 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3857 rplinit(int argc, char argv[], char en	Line 3873 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3937 rplinit(int argc, char argv[], char en	Line 3953 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 3993 rplinit(int argc, char argv[], char en	Line 4009 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4090 rplinit(int argc, char argv[], char en	Line 4106 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4149 rplinit(int argc, char argv[], char en	Line 4165 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4236 rplinit(int argc, char argv[], char en	Line 4252 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4284 rplinit(int argc, char argv[], char en	Line 4300 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4333 rplinit(int argc, char argv[], char en	Line 4349 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4381 rplinit(int argc, char argv[], char en	Line 4397 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4434 rplinit(int argc, char argv[], char en	Line 4450 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4507 rplinit(int argc, char argv[], char en	Line 4523 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4577 rplinit(int argc, char argv[], char en	Line 4593 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4628 rplinit(int argc, char argv[], char en	Line 4644 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4680 rplinit(int argc, char argv[], char en	Line 4696 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4744 rplinit(int argc, char argv[], char en	Line 4760 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4792 rplinit(int argc, char argv[], char en	Line 4808 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4836 rplinit(int argc, char argv[], char en	Line 4852 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4885 rplinit(int argc, char argv[], char en	Line 4901 rplinit(int argc, char argv[], char en
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,	sem_destroy2(semaphore_gestionnaires_signaux,
getpid(), SEM_SIGNAUX);	getpid(), SEM_SIGNAUX);
sem_destroy3((*s_etat_processus).semphore_fork,	sem_destroy3((*s_etat_processus).semaphore_fork,
getpid(), pthread_self(), SEM_FORK);	getpid(), pthread_self(), SEM_FORK);
# endif	# endif

Line 4937 rplinit(int argc, char argv[], char en	Line 4953 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 4991 rplinit(int argc, char argv[], char en	Line 5007 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 5040 rplinit(int argc, char argv[], char en	Line 5056 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 5094 rplinit(int argc, char argv[], char en	Line 5110 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 5372 rplinit(int argc, char argv[], char en	Line 5388 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 5590 rplinit(int argc, char argv[], char en	Line 5607 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 5608 rplinit(int argc, char argv[], char en	Line 5625 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 5653 rplinit(int argc, char argv[], char en	Line 5670 rplinit(int argc, char argv[], char en
semaphore_gestionnaires_signaux,	semaphore_gestionnaires_signaux,
getpid(), SEM_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

Line 5671 rplinit(int argc, char argv[], char en	Line 5688 rplinit(int argc, char argv[], char en
}	}
# endif	# endif

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

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

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

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

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

erreur_historique = write_history(	erreur_historique = write_history(
(*s_etat_processus).nom_fichier_historique);	(*s_etat_processus).nom_fichier_historique);
Line 6204 rplinit(int argc, char argv[], char en	Line 6229 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 6235 rplinit(int argc, char argv[], char en	Line 6262 rplinit(int argc, char argv[], char en

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

erreur = d_erreur;	erreur = d_erreur;
}	}

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

	#pragma GCC diagnostic pop

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

CVSweb interface <joel.bertrand@systella.fr>

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