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.69 and 1.87

version 1.69, 2011/06/21 15:26:35	version 1.87, 2011/09/18 12:42:50
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.2	RPL/2 (R) version 4.1.3
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 46 rplinit(int argc, char *argv[], unsigned	Line 46 rplinit(int argc, char *argv[], unsigned

int erreur_historique;	int erreur_historique;
int option_P;	int option_P;
int status;

logical1 core;	logical1 core;
logical1 debug;	logical1 debug;
Line 106 rplinit(int argc, char *argv[], unsigned	Line 105 rplinit(int argc, char *argv[], unsigned
volatile unsigned char traitement_fichier_temporaire;	volatile unsigned char traitement_fichier_temporaire;

errno = 0;	errno = 0;
	s_queue_signaux = NULL;
	pid_processus_pere = getpid();

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
debug_memoire_initialisation();	debug_memoire_initialisation();
Line 115 rplinit(int argc, char *argv[], unsigned	Line 116 rplinit(int argc, char *argv[], unsigned
setvbuf(stderr, NULL, _IOLBF, 0);	setvbuf(stderr, NULL, _IOLBF, 0);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_init(&semaphore_liste_threads, 0, 1);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);	sem_init(&semaphore_gestionnaires_signaux, 0, 0);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
# else	# else
semaphore_liste_threads = sem_init2(1, sem_liste_threads);	semaphore_gestionnaires_signaux = sem_init2(0, getpid());
semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
semaphore_gestionnaires_signaux_atomique = sem_init2(1,	if (semaphore_gestionnaires_signaux == SEM_FAILED)
sem_gestionnaires_signaux_atomique);

if ((semaphore_liste_threads == SEM_FAILED) \|\|
(semaphore_gestionnaires_signaux == SEM_FAILED) \|\|
(semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
{	{
erreur = d_es_allocation_memoire;	erreur = d_es_allocation_memoire;

Line 183 rplinit(int argc, char *argv[], unsigned	Line 177 rplinit(int argc, char *argv[], unsigned
(*s_etat_processus).langue = 'E';	(*s_etat_processus).langue = 'E';
}	}

	initialisation_contexte_cas(s_etat_processus);

(*s_etat_processus).exception = d_ep;	(*s_etat_processus).exception = d_ep;
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;
	(*s_etat_processus).compteur_violation_d_acces = 0;

(*s_etat_processus).rpl_home = rpl_home;	(*s_etat_processus).rpl_home = rpl_home;

Line 200 rplinit(int argc, char *argv[], unsigned	Line 197 rplinit(int argc, char *argv[], unsigned
&attributs_mutex);	&attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

# ifndef SEMAPHORES_NOMMES	pthread_mutexattr_init(&attributs_mutex);
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
# else	pthread_mutex_init(&((*s_etat_processus).mutex_fork),
if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==	&attributs_mutex);
SEM_FAILED)	pthread_mutexattr_destroy(&attributs_mutex);
{	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
if ((*s_etat_processus).langue == 'F')
{
uprintf("+++Système : Mémoire insuffisante\n");
}
else
{
uprintf("+++System : Not enough memory\n");
}

return(EXIT_FAILURE);
}
# endif

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);
Line 241 rplinit(int argc, char *argv[], unsigned	Line 226 rplinit(int argc, char *argv[], unsigned
recherche_chemin_fichiers_temporaires(s_etat_processus);	recherche_chemin_fichiers_temporaires(s_etat_processus);

# ifdef IPCS_SYSV	# ifdef IPCS_SYSV
# ifndef OS2	# ifndef OS2
chemin_semaphores_SysV = (*s_etat_processus).chemin_fichiers_temporaires;	chemin_semaphores_SysV =
# endif	(*s_etat_processus).chemin_fichiers_temporaires;
# endif	# endif

# ifdef _BROKEN_SIGINFO
creation_fifos_signaux(s_etat_processus);
# ifdef return
# undef return
# endif
# define return destruction_fifos_signaux(s_etat_processus); return
# endif	# endif

insertion_thread(s_etat_processus, d_vrai);	insertion_thread(s_etat_processus, d_vrai);
	creation_queue_signaux(s_etat_processus);

# ifndef OS2	# ifndef OS2
localisation_courante(s_etat_processus);	localisation_courante(s_etat_processus);
Line 336 rplinit(int argc, char *argv[], unsigned	Line 315 rplinit(int argc, char *argv[], unsigned
home = "";	home = "";
}	}

// Initialisation d'une clef

if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Système : Mémoire insuffisante\n");
}
else
{
printf("+++System : Not enough memory\n");
}

return(EXIT_FAILURE);
}

# ifndef SEMAPHORES_NOMMES
if (pthread_setspecific(semaphore_fork_processus_courant,
&((*s_etat_processus).semaphore_fork)) != 0)
# else
if (pthread_setspecific(semaphore_fork_processus_courant,
(*s_etat_processus).semaphore_fork) != 0)
# endif
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Système : Mémoire insuffisante\n");
}
else
{
printf("+++System : Not enough memory\n");
}

return(EXIT_FAILURE);
}

// Initialisation d'une pile de signal pour récupérer les	// Initialisation d'une pile de signal pour récupérer les
// débordement de pile	// débordement de pile

Line 414 rplinit(int argc, char *argv[], unsigned	Line 357 rplinit(int argc, char *argv[], unsigned
}	}
# endif	# endif

# ifndef _BROKEN_SIGINFO
action.sa_sigaction = interruption1;
# else
action.sa_handler = interruption1;	action.sa_handler = interruption1;
# endif	action.sa_flags = SA_ONSTACK;
action.sa_flags = SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGINT, &action, NULL) != 0)	if (sigaction(SIGINT, &action, NULL) != 0)
{	{
Line 438 rplinit(int argc, char *argv[], unsigned	Line 377 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

if (sigaction(SIGTERM, &action, NULL) != 0)	signal_test = SIGTEST;
	kill(getpid(), SIGINT);

	if (signal_test != SIGINT)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 455 rplinit(int argc, char *argv[], unsigned	Line 397 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	if (sigaction(SIGTERM, &action, NULL) != 0)
action.sa_sigaction = interruption2;
# else
action.sa_handler = interruption2;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGTSTP, &action, NULL) != 0)
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Système : Initialisation des signaux POSIX "
"impossible\n");
}
else
{
printf("+++System : Initialization of POSIX signals failed\n");
}

return(EXIT_FAILURE);
}

# ifndef _BROKEN_SIGINFO
action.sa_sigaction = interruption4;
# else
action.sa_handler = interruption4;
# endif
// SIGCONT ne doit pas pouvoir être appelé depuis son gestionnaire.
action.sa_flags = SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGSTART, &action, NULL) != 0)
{	{
if ((*s_etat_processus).langue == 'F')	erreur = d_es_signal;
{
printf("+++Système : Initialisation des signaux POSIX "
"impossible\n");
}
else
{
printf("+++System : Initialization of POSIX signals failed\n");
}

return(EXIT_FAILURE);
}

if (sigaction(SIGCONT, &action, NULL) != 0)
{
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Système : Initialisation des signaux POSIX "	printf("+++Système : Initialisation des signaux POSIX "
Line 515 rplinit(int argc, char *argv[], unsigned	Line 414 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	signal_test = SIGTEST;
action.sa_sigaction = interruption5;	kill(getpid(), SIGTERM);
# else
action.sa_handler = interruption5;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGFSTOP, &action, NULL) != 0)	if (signal_test != SIGTERM)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 539 rplinit(int argc, char *argv[], unsigned	Line 434 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	action.sa_handler = interruption2;
action.sa_sigaction = interruption11;	action.sa_flags = SA_NODEFER \| SA_ONSTACK;
# else
action.sa_handler = interruption11;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGFABORT, &action, NULL) != 0)	if (sigaction(SIGTSTP, &action, NULL) != 0)
{	{
erreur = d_es_signal;

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Système : Initialisation des signaux POSIX "	printf("+++Système : Initialisation des signaux POSIX "
Line 563 rplinit(int argc, char *argv[], unsigned	Line 452 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	signal_test = SIGTEST;
action.sa_sigaction = interruption8;	kill(getpid(), SIGTSTP);
# else
action.sa_handler = interruption8;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGURG, &action, NULL) != 0)	if (signal_test != SIGTSTP)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 587 rplinit(int argc, char *argv[], unsigned	Line 472 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	action.sa_handler = interruption5;
action.sa_sigaction = interruption7;	action.sa_flags = SA_NODEFER \| SA_ONSTACK;
# else
action.sa_handler = interruption7;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGPIPE, &action, NULL) != 0)	if (sigaction(SIGPIPE, &action, NULL) != 0)
{	{
Line 611 rplinit(int argc, char *argv[], unsigned	Line 492 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	signal_test = SIGTEST;
action.sa_sigaction = interruption6;	kill(getpid(), SIGPIPE);
# else
action.sa_handler = interruption6;
# endif
action.sa_flags = SA_ONSTACK \| SA_SIGINFO \| SA_NODEFER;

if (sigaction(SIGINJECT, &action, NULL) != 0)	if (signal_test != SIGPIPE)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 635 rplinit(int argc, char *argv[], unsigned	Line 512 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	action.sa_handler = interruption1;
action.sa_sigaction = interruption9;	action.sa_flags = SA_NODEFER \| SA_ONSTACK;
# else
action.sa_handler = interruption9;
# endif
action.sa_flags = SA_ONSTACK \| SA_SIGINFO \| SA_NODEFER;

if (sigaction(SIGABORT, &action, NULL) != 0)	if (sigaction(SIGALRM, &action, NULL) != 0)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 659 rplinit(int argc, char *argv[], unsigned	Line 532 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	signal_test = SIGTEST;
action.sa_sigaction = interruption1;	kill(getpid(), SIGALRM);
# else
action.sa_handler = interruption1;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGALRM, &action, NULL) != 0)	if (signal_test != SIGALRM)
{	{
erreur = d_es_signal;	erreur = d_es_signal;

Line 683 rplinit(int argc, char *argv[], unsigned	Line 552 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

# ifndef _BROKEN_SIGINFO	signal_test = SIGTEST + 1;
action.sa_sigaction = interruption3;
# else
action.sa_handler = interruption3;
# endif
action.sa_flags = SA_NODEFER \| SA_ONSTACK \| SA_SIGINFO;

erreur = d_absence_erreur;	erreur = d_absence_erreur;
core = d_faux;	core = d_faux;
Line 736 rplinit(int argc, char *argv[], unsigned	Line 600 rplinit(int argc, char *argv[], unsigned
option_t = d_faux;	option_t = d_faux;
option_v = d_faux;	option_v = d_faux;

	// Lorsque le programme est appelé depuis un shebang, argv[0] contient
	// le chemin du programme et argv[1] tous les arguments.
	// argv[2] contient quant à lui le nom du script RPL/2.
	//
	// Exemple :
	// argv[0] : /usr/local/bin/rpl
	// argv[1] : -csdp -t 800
	// argv[2] : ./on_exit.rpl

while((--argc) > 0)	while((--argc) > 0)
{	{
if ((*(++argv))[0] == '-')	if ((*(++argv))[0] == '-')
Line 1531 rplinit(int argc, char *argv[], unsigned	Line 1404 rplinit(int argc, char *argv[], unsigned
break;	break;
}	}

	case '-':
	case ' ':
	{
	break;
	}

default :	default :
{	{
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
Line 1577 rplinit(int argc, char *argv[], unsigned	Line 1456 rplinit(int argc, char *argv[], unsigned

if (debug == d_faux)	if (debug == d_faux)
{	{
	action.sa_handler = interruption3;
	action.sa_flags = SA_NODEFER \| SA_ONSTACK;

if (sigaction(SIGSEGV, &action, NULL) != 0)	if (sigaction(SIGSEGV, &action, NULL) != 0)
{	{
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
Line 1612 rplinit(int argc, char *argv[], unsigned	Line 1494 rplinit(int argc, char *argv[], unsigned

if (option_n == d_vrai)	if (option_n == d_vrai)
{	{
# ifndef _BROKEN_SIGINFO	action.sa_handler = interruption4;
action.sa_sigaction = interruption10;	action.sa_flags = SA_ONSTACK;
# else
action.sa_handler = interruption10;
# endif
action.sa_flags = SA_ONSTACK \| SA_SIGINFO;

if (sigaction(SIGHUP, &action, NULL) != 0)	if (sigaction(SIGHUP, &action, NULL) != 0)
{	{
Line 2011 rplinit(int argc, char *argv[], unsigned	Line 1889 rplinit(int argc, char *argv[], unsigned
(*s_etat_processus).var_volatile_recursivite = 0;	(*s_etat_processus).var_volatile_recursivite = 0;
(*s_etat_processus).var_volatile_exception_gsl = 0;	(*s_etat_processus).var_volatile_exception_gsl = 0;
(*s_etat_processus).arret_depuis_abort = 0;	(*s_etat_processus).arret_depuis_abort = 0;
	(*s_etat_processus).pointeur_signal_lecture = 0;
	(*s_etat_processus).pointeur_signal_ecriture = 0;

initialisation_allocateur(s_etat_processus);	initialisation_allocateur(s_etat_processus);
initialisation_drapeaux(s_etat_processus);	initialisation_drapeaux(s_etat_processus);
Line 2759 rplinit(int argc, char *argv[], unsigned	Line 2639 rplinit(int argc, char *argv[], unsigned
lancement_daemon(s_etat_processus);	lancement_daemon(s_etat_processus);
}	}

	// A FIXER
	// création signaux
if (option_p == d_faux)	if (option_p == d_faux)
{	{
if (setjmp(contexte_initial) == 0)	if (setjmp(contexte_initial) == 0)
{	{
erreur = sequenceur(s_etat_processus);	erreur = sequenceur(s_etat_processus);

	if (erreur == d_absence_erreur)
	{
	if (((*s_etat_processus).var_volatile_alarme
	== 0) && ((*s_etat_processus)
	.arret_depuis_abort == 0) &&
	((*s_etat_processus).at_exit
	!= NULL))
	{
	erreur = evaluation(s_etat_processus,
	(*s_etat_processus).at_exit,
	'E');
	}
	}
}	}
}	}
else	else
Line 2771 rplinit(int argc, char *argv[], unsigned	Line 2667 rplinit(int argc, char *argv[], unsigned
if (setjmp(contexte_initial) == 0)	if (setjmp(contexte_initial) == 0)
{	{
erreur = sequenceur_optimise(s_etat_processus);	erreur = sequenceur_optimise(s_etat_processus);
}
}

if (erreur == d_absence_erreur)	if (erreur == d_absence_erreur)
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).var_volatile_alarme
&& ((*s_etat_processus).arret_depuis_abort	== 0) && ((*s_etat_processus)
== 0) && ((*s_etat_processus).at_exit	.arret_depuis_abort == 0) &&
!= NULL))	((*s_etat_processus).at_exit
{	!= NULL))
erreur = evaluation(s_etat_processus,	{
(*s_etat_processus).at_exit, 'E');	erreur = evaluation(s_etat_processus,
	(*s_etat_processus).at_exit,
	'E');
	}
	}
}	}
}	}
	// A FIXER
	// destruction signaux
}	}

liberation(s_etat_processus, (*s_etat_processus).at_exit);	liberation(s_etat_processus, (*s_etat_processus).at_exit);
Line 2899 rplinit(int argc, char *argv[], unsigned	Line 2799 rplinit(int argc, char *argv[], unsigned
{	{
if ((*s_etat_processus).var_volatile_alarme != 0)	if ((*s_etat_processus).var_volatile_alarme != 0)
{	{
kill(((((struct_processus_fils *)	envoi_signal_processus(
	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, SIGURG);	.thread).pid, rpl_sigurg);
}	}
else	else
{	{
if ((*s_etat_processus).arret_depuis_abort	if ((*s_etat_processus).arret_depuis_abort
== -1)	== -1)
{	{
kill(((((struct_processus_fils *)	envoi_signal_processus(
	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, SIGFABORT);	.thread).pid, rpl_sigabort);
}	}
else	else
{	{
kill(((((struct_processus_fils *)	envoi_signal_processus(
	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).pid, SIGFSTOP);	.thread).pid, rpl_sigstop);
}	}
}	}
}	}
Line 2938 rplinit(int argc, char *argv[], unsigned	Line 2841 rplinit(int argc, char *argv[], unsigned
if ((*s_etat_processus).var_volatile_alarme	if ((*s_etat_processus).var_volatile_alarme
!= 0)	!= 0)
{	{
pthread_kill(((((struct_processus_fils *)	envoi_signal_thread(
	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee).objet))	l_element_courant)).donnee).objet))
.thread).tid, SIGURG);	.thread).tid, rpl_sigurg);
}	}
else	else
{	{
if ((*s_etat_processus).arret_depuis_abort	if ((*s_etat_processus).arret_depuis_abort
== -1)	== -1)
{	{
pthread_kill(	envoi_signal_thread(
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee)	l_element_courant)).donnee)
.objet)).thread).tid,	.objet)).thread).tid,
SIGFABORT);	rpl_sigabort);
}	}
else	else
{	{
pthread_kill(	envoi_signal_thread(
((((struct_processus_fils *)	((((struct_processus_fils *)
((((struct_liste_chainee *)	((((struct_liste_chainee *)
l_element_courant)).donnee)	l_element_courant)).donnee)
.objet)).thread).tid,	.objet)).thread).tid,
SIGFSTOP);	rpl_sigstop);
}	}
}	}
}	}
Line 2991 rplinit(int argc, char *argv[], unsigned	Line 2895 rplinit(int argc, char *argv[], unsigned

while((*s_etat_processus).l_base_pile_processus != NULL)	while((*s_etat_processus).l_base_pile_processus != NULL)
{	{
status = 0;

l_element_courant = (void *)	l_element_courant = (void *)
(*s_etat_processus).l_base_pile_processus;	(*s_etat_processus).l_base_pile_processus;

Line 3063 rplinit(int argc, char *argv[], unsigned	Line 2965 rplinit(int argc, char *argv[], unsigned
}	}

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

Line 3588 rplinit(int argc, char *argv[], unsigned	Line 3491 rplinit(int argc, char *argv[], unsigned
pthread_mutex_destroy(&((*s_etat_processus).mutex));	pthread_mutex_destroy(&((*s_etat_processus).mutex));
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));

# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));
sem_post(&((*s_etat_processus).semaphore_fork));	pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));
sem_destroy(&((*s_etat_processus).semaphore_fork));
# else
sem_post((*s_etat_processus).semaphore_fork);
sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
# endif

free((*s_etat_processus).localisation);	free((*s_etat_processus).localisation);

# ifndef SEMAPHORES_NOMMES	pthread_mutex_destroy(&mutex_liste_threads);
sem_destroy(&semaphore_liste_threads);	pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique);
# else
sem_destroy2(semaphore_liste_threads, sem_liste_threads);
# endif
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);	sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);	sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux_atomique);
# else	# else
sem_post(semaphore_gestionnaires_signaux);	sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);	sem_destroy2(semaphore_gestionnaires_signaux, getpid());
sem_destroy2(semaphore_gestionnaires_signaux_atomique,
sem_gestionnaires_signaux_atomique);
# endif	# endif

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
# undef return
# endif

free((*s_etat_processus).chemin_fichiers_temporaires);	free((*s_etat_processus).chemin_fichiers_temporaires);
free(s_etat_processus);	free(s_etat_processus);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.69
changed lines
	Added in v.1.87