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.132 and 1.155

version 1.132, 2013/02/23 18:32:15	version 1.155, 2014/04/25 08:18:59
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.12	RPL/2 (R) version 4.1.18
Copyright (C) 1989-2012 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 51 rplinit(int argc, char argv[], char en	Line 51 rplinit(int argc, char argv[], char en
int erreur_historique;	int erreur_historique;
int option_P;	int option_P;

	integer8 i;

logical1 core;	logical1 core;
logical1 debug;	logical1 debug;
logical1 erreur_fichier;	logical1 erreur_fichier;
Line 106 rplinit(int argc, char argv[], char en	Line 108 rplinit(int argc, char argv[], char en
unsigned char *ptr;	unsigned char *ptr;
unsigned char *tampon;	unsigned char *tampon;

unsigned long i;
unsigned long unite_fichier;	unsigned long unite_fichier;

void *l_element_courant;	void *l_element_courant;
Line 219 rplinit(int argc, char argv[], char en	Line 220 rplinit(int argc, char argv[], char en
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL)	if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);	sem_post(&semaphore_gestionnaires_signaux);
Line 241 rplinit(int argc, char argv[], char en	Line 242 rplinit(int argc, char argv[], char en
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

for(i = 0; i < (unsigned long) argc; i++)	for(i = 0; i < argc; i++)
{	{
arg_exec[i] = argv[i];	arg_exec[i] = argv[i];
}	}
Line 259 rplinit(int argc, char argv[], char en	Line 260 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 284 rplinit(int argc, char argv[], char en	Line 298 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 332 rplinit(int argc, char argv[], char en	Line 341 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 356 rplinit(int argc, char argv[], char en	Line 365 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 408 rplinit(int argc, char argv[], char en	Line 417 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 430 rplinit(int argc, char argv[], char en	Line 439 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");
}
else
{	{
printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n");	printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
	((*s_etat_processus).langue == 'F')
	? d_date_rpl : d_date_en_rpl);

	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 478 rplinit(int argc, char argv[], char en	Line 491 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 525 rplinit(int argc, char argv[], char en	Line 538 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 566 rplinit(int argc, char argv[], char en	Line 579 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 593 rplinit(int argc, char argv[], char en	Line 606 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGINT);	raise(SIGINT);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 615 rplinit(int argc, char argv[], char en	Line 628 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 653 rplinit(int argc, char argv[], char en	Line 666 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 680 rplinit(int argc, char argv[], char en	Line 693 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGTERM);	raise(SIGTERM);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 702 rplinit(int argc, char argv[], char en	Line 715 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 740 rplinit(int argc, char argv[], char en	Line 753 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 767 rplinit(int argc, char argv[], char en	Line 780 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGALRM);	raise(SIGALRM);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 789 rplinit(int argc, char argv[], char en	Line 802 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 830 rplinit(int argc, char argv[], char en	Line 843 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 855 rplinit(int argc, char argv[], char en	Line 868 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGTSTP);	raise(SIGTSTP);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 877 rplinit(int argc, char argv[], char en	Line 890 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 918 rplinit(int argc, char argv[], char en	Line 931 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 945 rplinit(int argc, char argv[], char en	Line 958 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGPIPE);	raise(SIGPIPE);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 967 rplinit(int argc, char argv[], char en	Line 980 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 1008 rplinit(int argc, char argv[], char en	Line 1021 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 1035 rplinit(int argc, char argv[], char en	Line 1048 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGUSR1);	raise(SIGUSR1);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 1057 rplinit(int argc, char argv[], char en	Line 1070 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 1163 rplinit(int argc, char argv[], char en	Line 1176 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 1207 rplinit(int argc, char argv[], char en	Line 1220 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 1258 rplinit(int argc, char argv[], char en	Line 1271 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 1321 rplinit(int argc, char argv[], char en	Line 1334 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 1374 rplinit(int argc, char argv[], char en	Line 1387 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 1417 rplinit(int argc, char argv[], char en	Line 1430 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 1462 rplinit(int argc, char argv[], char en	Line 1475 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 1507 rplinit(int argc, char argv[], char en	Line 1520 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 1551 rplinit(int argc, char argv[], char en	Line 1564 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 1596 rplinit(int argc, char argv[], char en	Line 1609 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 1633 rplinit(int argc, char argv[], char en	Line 1646 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 1670 rplinit(int argc, char argv[], char en	Line 1683 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 1716 rplinit(int argc, char argv[], char en	Line 1729 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 1770 rplinit(int argc, char argv[], char en	Line 1783 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 1815 rplinit(int argc, char argv[], char en	Line 1828 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 1852 rplinit(int argc, char argv[], char en	Line 1865 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 1897 rplinit(int argc, char argv[], char en	Line 1910 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 1942 rplinit(int argc, char argv[], char en	Line 1955 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 1987 rplinit(int argc, char argv[], char en	Line 2000 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 2024 rplinit(int argc, char argv[], char en	Line 2037 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 2076 rplinit(int argc, char argv[], char en	Line 2089 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 2137 rplinit(int argc, char argv[], char en	Line 2150 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 2187 rplinit(int argc, char argv[], char en	Line 2200 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 2227 rplinit(int argc, char argv[], char en	Line 2240 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 2253 rplinit(int argc, char argv[], char en	Line 2266 rplinit(int argc, char argv[], char en
}	}

(*s_etat_processus).longueur_definitions_chainees =	(*s_etat_processus).longueur_definitions_chainees =
strlen((*s_etat_processus)	(integer8) strlen((*s_etat_processus)
.definitions_chainees);	.definitions_chainees);

break;	break;
Line 2274 rplinit(int argc, char argv[], char en	Line 2287 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 2326 rplinit(int argc, char argv[], char en	Line 2339 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 2387 rplinit(int argc, char argv[], char en	Line 2400 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 2436 rplinit(int argc, char argv[], char en	Line 2449 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 2511 rplinit(int argc, char argv[], char en	Line 2524 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 2558 rplinit(int argc, char argv[], char en	Line 2571 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 2602 rplinit(int argc, char argv[], char en	Line 2615 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 2731 rplinit(int argc, char argv[], char en	Line 2744 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 2774 rplinit(int argc, char argv[], char en	Line 2787 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 2800 rplinit(int argc, char argv[], char en	Line 2813 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGSEGV);	raise(SIGSEGV);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 2823 rplinit(int argc, char argv[], char en	Line 2836 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 2867 rplinit(int argc, char argv[], char en	Line 2880 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 2900 rplinit(int argc, char argv[], char en	Line 2913 rplinit(int argc, char argv[], char en
}	}

signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGBUS);	raise(SIGBUS);

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = 1000000;	attente.tv_nsec = 1000000;
Line 2923 rplinit(int argc, char argv[], char en	Line 2936 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 2977 rplinit(int argc, char argv[], char en	Line 2990 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 3048 rplinit(int argc, char argv[], char en	Line 3061 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 3092 rplinit(int argc, char argv[], char en	Line 3105 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 3135 rplinit(int argc, char argv[], char en	Line 3148 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 3179 rplinit(int argc, char argv[], char en	Line 3192 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 3222 rplinit(int argc, char argv[], char en	Line 3235 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 3287 rplinit(int argc, char argv[], char en	Line 3300 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 3347 rplinit(int argc, char argv[], char en	Line 3360 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 3403 rplinit(int argc, char argv[], char en	Line 3416 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 3613 rplinit(int argc, char argv[], char en	Line 3627 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 3656 rplinit(int argc, char argv[], char en	Line 3670 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 3713 rplinit(int argc, char argv[], char en	Line 3727 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 3803 rplinit(int argc, char argv[], char en	Line 3817 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 3855 rplinit(int argc, char argv[], char en	Line 3869 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 3935 rplinit(int argc, char argv[], char en	Line 3949 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 3991 rplinit(int argc, char argv[], char en	Line 4005 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 4088 rplinit(int argc, char argv[], char en	Line 4102 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 4147 rplinit(int argc, char argv[], char en	Line 4161 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 4234 rplinit(int argc, char argv[], char en	Line 4248 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 4282 rplinit(int argc, char argv[], char en	Line 4296 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 4331 rplinit(int argc, char argv[], char en	Line 4345 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 4379 rplinit(int argc, char argv[], char en	Line 4393 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 4432 rplinit(int argc, char argv[], char en	Line 4446 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 4482 rplinit(int argc, char argv[], char en	Line 4496 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 4505 rplinit(int argc, char argv[], char en	Line 4519 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 4575 rplinit(int argc, char argv[], char en	Line 4589 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 4626 rplinit(int argc, char argv[], char en	Line 4640 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 4678 rplinit(int argc, char argv[], char en	Line 4692 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 4742 rplinit(int argc, char argv[], char en	Line 4756 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 4790 rplinit(int argc, char argv[], char en	Line 4804 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 4834 rplinit(int argc, char argv[], char en	Line 4848 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 4883 rplinit(int argc, char argv[], char en	Line 4897 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 4904 rplinit(int argc, char argv[], char en	Line 4918 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 4933 rplinit(int argc, char argv[], char en	Line 4949 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 4987 rplinit(int argc, char argv[], char en	Line 5003 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 5036 rplinit(int argc, char argv[], char en	Line 5052 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 5090 rplinit(int argc, char argv[], char en	Line 5106 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 5138 rplinit(int argc, char argv[], char en	Line 5154 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 5159 rplinit(int argc, char argv[], char en	Line 5255 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 5208 rplinit(int argc, char argv[], char en	Line 5384 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 5380 rplinit(int argc, char argv[], char en	Line 5557 rplinit(int argc, char argv[], char en
l_element_courant = (void *)	l_element_courant = (void *)
(*s_etat_processus).l_base_pile_processus;	(*s_etat_processus).l_base_pile_processus;

for(i = 0; i < (unsigned long)	for(i = 0; i < ((((struct_processus_fils *)
((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet)).thread)	l_element_courant)).donnee).objet)).thread)
.nombre_objets_dans_pipe; i++)	.nombre_objets_dans_pipe; i++)
Line 5427 rplinit(int argc, char argv[], char en	Line 5603 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 5445 rplinit(int argc, char argv[], char en	Line 5621 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 5490 rplinit(int argc, char argv[], char en	Line 5666 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 5508 rplinit(int argc, char argv[], char en	Line 5684 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 5701 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 5721 rplinit(int argc, char argv[], char en	Line 5904 rplinit(int argc, char argv[], char en
{	{
free((*resultats));	free((*resultats));

if (((resultats) = malloc(((s_etat_processus)	if (((*resultats) = malloc(((size_t)
.hauteur_pile_operationnelle + 1)	((*s_etat_processus)
	.hauteur_pile_operationnelle + 1))
* sizeof(unsigned char **))) != NULL)	* sizeof(unsigned char **))) != NULL)
{	{
(resultats)[(s_etat_processus)	(resultats)[(s_etat_processus)
Line 6041 rplinit(int argc, char argv[], char en	Line 6225 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);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.132
changed lines
	Added in v.1.155