rpl/src/instructions_d5.c - diff

Return to instructions_d5.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d5.c between versions 1.49.2.3 and 1.173

version 1.49.2.3, 2011/05/09 13:52:15	version 1.173, 2020/01/10 11:15:44
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.24	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2020 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 40 instruction_dft(struct_processus *s_etat	Line 40 instruction_dft(struct_processus *s_etat
{	{
integer4 erreur;	integer4 erreur;
integer4 inverse;	integer4 inverse;
	integer4 longueur_dft;
integer4 nombre_colonnes;	integer4 nombre_colonnes;
integer4 nombre_lignes;	integer4 nombre_lignes;

logical1 presence_longueur_dft;	logical1 presence_longueur_dft;

long longueur_dft_signee;	integer8 longueur_dft_signee;

struct_complexe16 *matrice_f77;	struct_complexe16 *matrice_f77;

Line 53 instruction_dft(struct_processus *s_etat	Line 54 instruction_dft(struct_processus *s_etat
struct_objet *s_objet_longueur_dft;	struct_objet *s_objet_longueur_dft;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long longueur_dft;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 135 instruction_dft(struct_processus *s_etat	Line 135 instruction_dft(struct_processus *s_etat
return;	return;
}	}

longueur_dft = longueur_dft_signee;	longueur_dft = (integer4) longueur_dft_signee;
}	}
else	else
{	{
Line 170 instruction_dft(struct_processus *s_etat	Line 170 instruction_dft(struct_processus *s_etat
{	{
if (presence_longueur_dft == d_faux)	if (presence_longueur_dft == d_faux)
{	{
longueur_dft = (((struct_vecteur )	longueur_dft = (integer4) (((struct_vecteur )
(*s_objet_argument).objet)).taille;	(*s_objet_argument).objet)).taille;
}	}

if ((matrice_f77 = malloc(longueur_dft *	if ((matrice_f77 = malloc(((size_t) longueur_dft) *
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 260 instruction_dft(struct_processus *s_etat	Line 260 instruction_dft(struct_processus *s_etat
{	{
if (presence_longueur_dft == d_faux)	if (presence_longueur_dft == d_faux)
{	{
longueur_dft = (((struct_matrice )	longueur_dft = (integer4) (((struct_matrice )
(*s_objet_argument).objet)).nombre_colonnes;	(*s_objet_argument).objet)).nombre_colonnes;
}	}

if ((matrice_f77 = malloc(longueur_dft *	if ((matrice_f77 = malloc(((size_t) longueur_dft) * ((size_t)
(((struct_matrice ) (*s_objet_argument).objet))	(((struct_matrice ) (*s_objet_argument).objet))
.nombre_lignes * sizeof(struct_complexe16))) == NULL)	.nombre_lignes) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 342 instruction_dft(struct_processus *s_etat	Line 342 instruction_dft(struct_processus *s_etat
}	}
}	}

nombre_lignes = (((struct_matrice ) (*s_objet_argument).objet))	nombre_lignes = (integer4) (((struct_matrice ) (*s_objet_argument)
.nombre_lignes;	.objet)).nombre_lignes;
nombre_colonnes = longueur_dft;	nombre_colonnes = longueur_dft;
inverse = 0;	inverse = 0;

Line 371 instruction_dft(struct_processus *s_etat	Line 371 instruction_dft(struct_processus *s_etat
longueur_dft;	longueur_dft;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet_resultat)
.nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 383 instruction_dft(struct_processus *s_etat	Line 383 instruction_dft(struct_processus *s_etat
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 767 instruction_der(struct_processus *s_etat	Line 767 instruction_der(struct_processus *s_etat
if ((s_objet_simplifie = simplification(s_etat_processus,	if ((s_objet_simplifie = simplification(s_etat_processus,
s_objet_resultat)) == NULL)	s_objet_resultat)) == NULL)
{	{
	liberation(s_etat_processus, s_objet_resultat);
return;	return;
}	}

Line 814 instruction_der(struct_processus *s_etat	Line 815 instruction_der(struct_processus *s_etat
void	void
instruction_detach(struct_processus *s_etat_processus)	instruction_detach(struct_processus *s_etat_processus)
{	{
int status;	int pipe_initialisation_segment_signaux[2];

logical1 drapeau;	logical1 drapeau;
logical1 variable_partagee;

pid_t ppid;	pid_t ppid;
pid_t pid_final;

pthread_attr_t attributs;	pthread_attr_t attributs;

pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;

pthread_t thread_surveillance;	pthread_t thread_surveillance;

sig_atomic_t registre_stop;	sig_atomic_t registre_stop;

sigset_t oldset;	ssize_t longueur_ecriture;
sigset_t oldset2;
sigset_t set;
sigset_t set2;

ssize_t longueur_ecriture;	struct_descripteur_thread *s_argument_thread;
	struct_descripteur_thread *s_argument_thread2;

struct_descripteur_thread *s_argument_thread;	struct_liste_chainee *l_element_courant;
struct_descripteur_thread *s_argument_thread2;	struct_liste_chainee *l_element_precedent;
	struct_liste_chainee *l_element_suivant;

struct_liste_chainee *l_element_courant;	struct_liste_variables_partagees *l_element_partage_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_variables_partagees *l_element_partage_suivant;
struct_liste_chainee *l_element_suivant;

struct_objet *s_copie;	struct_liste_variables_statiques *l_element_statique_courant;
struct_objet *s_objet;	struct_liste_variables_statiques *l_element_statique_suivant;
struct_objet *s_objet_systeme;
struct_objet *s_objet_temporaire;

struct sigaction action;	struct_objet *s_copie;
struct sigaction registre;	struct_objet *s_objet;
	struct_objet *s_objet_systeme;
	struct_objet *s_objet_temporaire;

struct timespec attente;	struct sigaction action;
	struct sigaction registre;

unsigned char *message;	struct timespec attente;

unsigned int erreur;	unsigned char caractere;
	unsigned char *message;

unsigned long i;	unsigned int erreur;

	integer8 i;

	volatile logical1 variable_partagee;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 931 instruction_detach(struct_processus *s_e	Line 934 instruction_detach(struct_processus *s_e
if (recherche_variable(s_etat_processus, (((struct_nom )	if (recherche_variable(s_etat_processus, (((struct_nom )
(*s_objet).objet)).nom) == d_vrai)	(*s_objet).objet)).nom) == d_vrai)
{	{
if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante).objet
[(*s_etat_processus).position_variable_courante].objet
== NULL)	== NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante).nom,
[(*s_etat_processus).position_variable_courante].nom,	((s_etat_processus).pointeur_variable_courante)
(*s_etat_processus).s_liste_variables	.variable_partagee, ((s_etat_processus)
[(*s_etat_processus).position_variable_courante]	.pointeur_variable_courante).origine) == NULL)
.variable_partagee, (*s_etat_processus)
.s_liste_variables[(*s_etat_processus)
.position_variable_courante].origine) == d_faux)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
Line 966 instruction_detach(struct_processus *s_e	Line 951 instruction_detach(struct_processus *s_e
return;	return;
}	}

if (((((*s_etat_processus).s_liste_variables_partagees)	if (((((*s_etat_processus)
.table[((s_etat_processus)	.pointeur_variable_partagee_courante).objet).type
.s_liste_variables_partagees).position_variable].objet)	== RPN) && ((((*s_etat_processus)
.type != RPN) && ((((*s_etat_processus)	.pointeur_variable_partagee_courante).objet).type
.s_liste_variables_partagees).table	== ADR))
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet).type != ADR))
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 989 instruction_detach(struct_processus *s_e	Line 972 instruction_detach(struct_processus *s_e
}	}

if ((s_copie = copie_objet(s_etat_processus,	if ((s_copie = copie_objet(s_etat_processus,
((s_etat_processus).s_liste_variables_partagees).table	((s_etat_processus)
[((s_etat_processus).s_liste_variables_partagees)	.pointeur_variable_partagee_courante).objet, 'P'))
.position_variable].objet, 'P')) == NULL)	== NULL)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1009 instruction_detach(struct_processus *s_e	Line 992 instruction_detach(struct_processus *s_e
variable_partagee = d_vrai;	variable_partagee = d_vrai;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1017 instruction_detach(struct_processus *s_e	Line 1000 instruction_detach(struct_processus *s_e
}	}
else	else
{	{
if ((((s_etat_processus).s_liste_variables	if (((((*s_etat_processus).pointeur_variable_courante).objet)
[(*s_etat_processus).position_variable_courante].objet)	.type != RPN) && ((((*s_etat_processus)
.type != RPN) && (((s_etat_processus)	.pointeur_variable_courante).objet).type != ADR))
.s_liste_variables[(*s_etat_processus)
.position_variable_courante].objet).type != ADR))
{	{
liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);

Line 1041 instruction_detach(struct_processus *s_e	Line 1022 instruction_detach(struct_processus *s_e
}	}
}	}

if (sigemptyset(&set) != 0)	if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (sigaddset(&set, SIGSTART) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

/*	if (pipe((*s_argument_thread).pipe_erreurs) != 0)
* Le signal SIGFSTOP doit être traité !
*/

if (sigaddset(&set, SIGFSTOP) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (sigaddset(&set, SIGFABORT) != 0)	if (pipe((*s_argument_thread).pipe_interruptions) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (sigaddset(&set, SIGURG) != 0)	if (pipe((*s_argument_thread).pipe_nombre_elements_attente) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pthread_sigmask(SIG_BLOCK, &set, &oldset) != 0)	if (pipe((*s_argument_thread).pipe_objets) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)	if (pipe((*s_argument_thread).pipe_acquittement) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_erreurs) != 0)	if (pipe((*s_argument_thread).pipe_injections) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_interruptions) != 0)	if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)	if (pipe(pipe_initialisation_segment_signaux) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_objets) != 0)	ppid = getpid();
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (pipe((*s_argument_thread).pipe_acquittement) != 0)	/*
{	* Le mutex suivant permet de copier un contexte propre.
(*s_etat_processus).erreur_systeme = d_es_processus;	*/
return;
}

if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_injections) != 0)	verrouillage_threads_concurrents(s_etat_processus);
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)	if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

ppid = getpid();	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)

/*
* Le mutex suivant permet de copier un contexte propre.
*/

if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1154 instruction_detach(struct_processus *s_e	Line 1109 instruction_detach(struct_processus *s_e
* de mémoire, ni libération, ni copie d'objet concurrent au fork().	* de mémoire, ni libération, ni copie d'objet concurrent au fork().
*/	*/

sigfillset(&set2);
pthread_sigmask(SIG_BLOCK, &set2, &oldset2);

verrouillage_threads_concurrents(s_etat_processus);
(*s_argument_thread).pid = fork();	(*s_argument_thread).pid = fork();
deverrouillage_threads_concurrents(s_etat_processus);

pthread_sigmask(SIG_SETMASK, &oldset2, NULL);	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation_buffer))
sigpending(&set2);	!= 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if ((*s_argument_thread).pid > 0)
	{
	// On ne déverrouille les threads concurrents que dans le processus
	// père. Dans le fils, les valeurs sont non initialisées.
	deverrouillage_threads_concurrents(s_etat_processus);
	}

(*s_argument_thread).thread_pere = pthread_self();	(*s_argument_thread).thread_pere = pthread_self();
(*s_argument_thread).processus_detache = d_vrai;	(*s_argument_thread).processus_detache = d_vrai;
Line 1184 instruction_detach(struct_processus *s_e	Line 1145 instruction_detach(struct_processus *s_e
* Processus père	* Processus père
*/	*/

	if (pthread_mutex_unlock(&mutex_liste_variables_partagees) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
liberation(s_etat_processus, s_copie);	liberation(s_etat_processus, s_copie);
Line 1231 instruction_detach(struct_processus *s_e	Line 1198 instruction_detach(struct_processus *s_e
return;	return;
}	}

if (close((*s_argument_thread).pipe_nombre_interruptions_attente[1])	if (close((*s_argument_thread).pipe_nombre_elements_attente[1])
!= 0)	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1244 instruction_detach(struct_processus *s_e	Line 1211 instruction_detach(struct_processus *s_e
return;	return;
}	}

if (close((*s_argument_thread).pipe_nombre_objets_attente[1]) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (close((*s_argument_thread).pipe_injections[0]) != 0)	if (close((*s_argument_thread).pipe_injections[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1281 instruction_detach(struct_processus *s_e	Line 1242 instruction_detach(struct_processus *s_e
return;	return;
}	}

# ifndef OS2	# ifdef SCHED_OTHER
# ifndef Cygwin
if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)	if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# endif

	# ifdef PTHREAD_EXPLICIT_SCHED
if (pthread_attr_setinheritsched(&attributs,	if (pthread_attr_setinheritsched(&attributs,
PTHREAD_EXPLICIT_SCHED) != 0)	PTHREAD_EXPLICIT_SCHED) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# endif

	# ifdef PTHREAD_SCOPE_SYSTEM
if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)	if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif	# endif
# endif

(*s_argument_thread).s_etat_processus = s_etat_processus;	(*s_argument_thread).s_etat_processus = s_etat_processus;

Line 1325 instruction_detach(struct_processus *s_e	Line 1288 instruction_detach(struct_processus *s_e
* Processus fils	* Processus fils
*/	*/

# ifdef _BROKEN_SIGINFO	// EPERM
liberation_fifos_signaux(s_etat_processus);	#if 0
creation_fifos_signaux(s_etat_processus);	pthread_mutex_destroy(&mutex_liste_variables_partagees);
# endif	pthread_mutex_destroy(&mutex_liste_threads);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
	#endif
	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_liste_threads_surveillance, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_sigaction, &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_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_allocation),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	liberation_queue_signaux(s_etat_processus);
	creation_queue_signaux(s_etat_processus);

	routine_recursive = 0;
	nombre_threads_surveillance_processus = 0;

	(*s_etat_processus).pointeur_signal_lecture = 0;
	(*s_etat_processus).pointeur_signal_ecriture = 0;

	if (write_atomic(s_etat_processus,
	pipe_initialisation_segment_signaux[1],
	"-", sizeof(unsigned char)) != sizeof(unsigned char))
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}

	close(pipe_initialisation_segment_signaux[0]);
	close(pipe_initialisation_segment_signaux[1]);

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
if (((*s_etat_processus).type_debug &	if (((*s_etat_processus).type_debug &
Line 1348 instruction_detach(struct_processus *s_e	Line 1364 instruction_detach(struct_processus *s_e
fflush(stdout);	fflush(stdout);
}	}

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,
sem_gestionnaires_signaux);

if ((semaphore_gestionnaires_signaux = sem_init2(0,
sem_gestionnaires_signaux)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
# endif

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_liste_threads);
sem_destroy(&semaphore_liste_threads);
sem_init(&semaphore_liste_threads, 0, 1);
# else
sem_post(semaphore_liste_threads);
sem_destroy2(semaphore_liste_threads, sem_liste_threads);

if ((semaphore_liste_threads = sem_init2(1,
sem_liste_threads)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
# endif

# ifndef SEMAPHORES_NOMMES
sem_destroy(&semaphore_gestionnaires_signaux_atomique);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
sem_trywait(&((*s_etat_processus).semaphore_fork));
# else
sem_destroy2(semaphore_gestionnaires_signaux_atomique,
sem_gestionnaires_signaux_atomique);

if ((semaphore_gestionnaires_signaux_atomique = sem_init2(1,
sem_gestionnaires_signaux_atomique)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

sem_trywait((*s_etat_processus).semaphore_fork);
# endif

# 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
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

if (close((*s_argument_thread).pipe_erreurs[0]) != 0)	if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1416 instruction_detach(struct_processus *s_e	Line 1373 instruction_detach(struct_processus *s_e
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}
else if (close((*s_argument_thread)	else if (close((*s_argument_thread)
.pipe_nombre_interruptions_attente[0]) != 0)	.pipe_nombre_elements_attente[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}
Line 1424 instruction_detach(struct_processus *s_e	Line 1381 instruction_detach(struct_processus *s_e
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}
else if (close((*s_argument_thread).pipe_nombre_objets_attente[0]) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
else if (close((*s_argument_thread).pipe_injections[1]) != 0)	else if (close((*s_argument_thread).pipe_injections[1]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1461 instruction_detach(struct_processus *s_e	Line 1414 instruction_detach(struct_processus *s_e
l_element_courant = (*s_etat_processus).liste_mutexes;	l_element_courant = (*s_etat_processus).liste_mutexes;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
pthread_mutex_trylock(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));
pthread_mutex_unlock(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));
pthread_mutex_destroy(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));

liberation(s_etat_processus, (*l_element_courant).donnee);	liberation(s_etat_processus, (*l_element_courant).donnee);
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);	free(l_element_courant);
Line 1477 instruction_detach(struct_processus *s_e	Line 1423 instruction_detach(struct_processus *s_e
(*s_etat_processus).liste_mutexes = NULL;	(*s_etat_processus).liste_mutexes = NULL;

liberation_threads(s_etat_processus);	liberation_threads(s_etat_processus);

((s_etat_processus).s_liste_variables_partagees)
.table = NULL;
((s_etat_processus).s_liste_variables_partagees)
.nombre_variables = 0;
((s_etat_processus).s_liste_variables_partagees)
.nombre_variables_allouees = 0;

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

// Envoi d'une donnée pour signaler le démarrage du processus au thread	// Envoi d'une donnée pour signaler le démarrage du processus au thread
// de surveillance.	// de surveillance.

	caractere = 0;

if (write_atomic(s_etat_processus,	if (write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
"-", sizeof(unsigned char)) != sizeof(unsigned char))	&caractere, sizeof(caractere)) != sizeof(caractere))
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;

pid_final = -2;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1519 instruction_detach(struct_processus *s_e	Line 1446 instruction_detach(struct_processus *s_e
}	}
}	}

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	if (pthread_mutex_destroy(&mutex_sections_critiques) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;

pid_final = -2;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1553 instruction_detach(struct_processus *s_e	Line 1465 instruction_detach(struct_processus *s_e
}	}
}	}

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}

pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
if (pthread_mutex_unlock(&((*s_etat_processus)	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
.protection_liste_mutexes)) != 0)	pthread_mutexattr_destroy(&attributs_mutex);
{
(*s_etat_processus).erreur_systeme = d_es_processus;

pid_final = -2;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

# ifdef _BROKEN_SIGINFO
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);
}

if ((*s_etat_processus).evaluation_expression_compilee == 'N')	if ((*s_etat_processus).evaluation_expression_compilee == 'N')
{	{
Line 1652 instruction_detach(struct_processus *s_e	Line 1529 instruction_detach(struct_processus *s_e
* renseignée.	* renseignée.
*/	*/

if (sigpending(&set) != 0)	// Attente de la réception du signal rpl_sigstart.
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
else if (sigismember(&set, SIGSTART) == 0)
{
while(sigismember(&set, SIGSTART) == 0)
{
if (sigpending(&set) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

nanosleep(&attente, NULL);	for((*s_etat_processus).demarrage_fils = d_faux;
}	(*s_etat_processus).demarrage_fils != d_vrai;
	nanosleep(&attente, NULL))
	{
	scrutation_interruptions(s_etat_processus);
}	}

(s_etat_processus).niveau_initial = (s_etat_processus).niveau_courant;	(s_etat_processus).niveau_initial = (s_etat_processus).niveau_courant;
(*s_etat_processus).presence_pipes = d_vrai;	(*s_etat_processus).presence_pipes = d_vrai;
(*s_etat_processus).debug_programme = d_faux;	(*s_etat_processus).debug_programme = d_faux;
(s_etat_processus).pipe_donnees = (s_argument_thread).pipe_objets[1];	(s_etat_processus).pipe_donnees = (s_argument_thread).pipe_objets[1];
(s_etat_processus).pipe_nombre_objets_attente = (s_argument_thread)	(s_etat_processus).pipe_nombre_elements_attente = (s_argument_thread)
.pipe_nombre_objets_attente[1];	.pipe_nombre_elements_attente[1];
(s_etat_processus).pipe_interruptions = (s_argument_thread)	(s_etat_processus).pipe_interruptions = (s_argument_thread)
.pipe_interruptions[1];	.pipe_interruptions[1];
(*s_etat_processus).pipe_nombre_interruptions_attente =
(*s_argument_thread).pipe_nombre_interruptions_attente[1];
(*s_etat_processus).pipe_injections =	(*s_etat_processus).pipe_injections =
(*s_argument_thread).pipe_injections[0];	(*s_argument_thread).pipe_injections[0];
(*s_etat_processus).pipe_nombre_injections =	(*s_etat_processus).pipe_nombre_injections =
Line 1691 instruction_detach(struct_processus *s_e	Line 1558 instruction_detach(struct_processus *s_e
(*s_etat_processus).presence_fusible = d_faux;	(*s_etat_processus).presence_fusible = d_faux;
(*s_etat_processus).thread_fusible = 0;	(*s_etat_processus).thread_fusible = 0;
(*s_etat_processus).pid_erreur_processus_fils = getpid();	(*s_etat_processus).pid_erreur_processus_fils = getpid();
	(*s_etat_processus).sections_critiques = 0;
	(*s_etat_processus).initialisation_scheduler = d_faux;

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
Line 1717 instruction_detach(struct_processus *s_e	Line 1586 instruction_detach(struct_processus *s_e
* par liberation_threads().	* par liberation_threads().
*/	*/

if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;

pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1743 instruction_detach(struct_processus *s_e	Line 1603 instruction_detach(struct_processus *s_e
}	}
}	}

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 1763 instruction_detach(struct_processus *s_e	Line 1620 instruction_detach(struct_processus *s_e
(*s_argument_thread2).nombre_references--;	(*s_argument_thread2).nombre_references--;

BUG((*s_argument_thread2).nombre_references < 0,	BUG((*s_argument_thread2).nombre_references < 0,
# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus),
destruction_fifos_signaux(s_etat_processus),
# endif
printf("(*s_argument_thread2).nombre_references = %d\n",	printf("(*s_argument_thread2).nombre_references = %d\n",
(int) (*s_argument_thread2).nombre_references));	(int) (*s_argument_thread2).nombre_references));

Line 1775 instruction_detach(struct_processus *s_e	Line 1630 instruction_detach(struct_processus *s_e
close((*s_argument_thread2).pipe_acquittement[1]);	close((*s_argument_thread2).pipe_acquittement[1]);
close((*s_argument_thread2).pipe_injections[1]);	close((*s_argument_thread2).pipe_injections[1]);
close((*s_argument_thread2).pipe_nombre_injections[1]);	close((*s_argument_thread2).pipe_nombre_injections[1]);
close((*s_argument_thread2).pipe_nombre_objets_attente[0]);	close((*s_argument_thread2).pipe_nombre_elements_attente[0]);
close((*s_argument_thread2).pipe_interruptions[0]);	close((*s_argument_thread2).pipe_interruptions[0]);
close((*s_argument_thread2)
.pipe_nombre_interruptions_attente[0]);

pthread_mutex_destroy(&((*s_argument_thread2).mutex));	pthread_mutex_destroy(&((*s_argument_thread2).mutex));

Line 1803 instruction_detach(struct_processus *s_e	Line 1656 instruction_detach(struct_processus *s_e

(*s_etat_processus).l_base_pile_processus = NULL;	(*s_etat_processus).l_base_pile_processus = NULL;

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;

pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1819 instruction_detach(struct_processus *s_e	Line 1673 instruction_detach(struct_processus *s_e
}	}
}	}

while((longueur_ecriture = write_atomic(s_etat_processus,	destruction_queue_signaux(s_etat_processus);
(*s_argument_thread).pipe_nombre_objets_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

# ifdef _BROKEN_SIGINFO
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 1875 instruction_detach(struct_processus *s_e	Line 1716 instruction_detach(struct_processus *s_e

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1897 instruction_detach(struct_processus *s_e	Line 1728 instruction_detach(struct_processus *s_e
}	}
}	}

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 1931 instruction_detach(struct_processus *s_e	Line 1759 instruction_detach(struct_processus *s_e

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1943 instruction_detach(struct_processus *s_e	Line 1771 instruction_detach(struct_processus *s_e
}	}
}	}

while((longueur_ecriture = write_atomic(s_etat_processus,	destruction_queue_signaux(s_etat_processus);
(*s_argument_thread).pipe_nombre_objets_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

# ifdef _BROKEN_SIGINFO
destruction_fifos_signaux(s_etat_processus);
# endif

BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 2026 instruction_detach(struct_processus *s_e	Line 1841 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

	(*s_etat_processus).s_fichiers = NULL;

/*	/*
* Destruction des piles de connecteurs SQL	* Destruction des piles de connecteurs SQL
*/	*/
Line 2048 instruction_detach(struct_processus *s_e	Line 1865 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

(*s_etat_processus).s_connecteurs_sql = NULL;

/*	/*
* On ne détruit pas les sockets car il faut utiliser DETACH	* On ne détruit pas les sockets car il faut utiliser DETACH
* pour traiter plusieurs connexions simultanées sur les sockets	* pour traiter plusieurs connexions simultanées sur les sockets
*/	*/

(*s_etat_processus).s_fichiers = NULL;	(*s_etat_processus).s_connecteurs_sql = NULL;

if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

sigpending(&set);

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
{	{
Line 2082 instruction_detach(struct_processus *s_e	Line 1890 instruction_detach(struct_processus *s_e

if ((*s_etat_processus).erreur_systeme == d_es)	if ((*s_etat_processus).erreur_systeme == d_es)
{	{
if (variable_partagee == d_faux)	// Évite le warning variable s_copie might be clobbered by
	// longjmp or vfork
	struct_objet **s;

	if ((s = malloc(sizeof(struct_objet *))) == NULL)
{	{
if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)	(*s_etat_processus).erreur_execution = d_es_allocation_memoire;
{	return;
if (((*s_etat_processus).erreur_execution == d_ex) &&	}
((*s_etat_processus).erreur_systeme == d_es))
{	(*s) = s_copie;
(*s_etat_processus).erreur_execution =
d_ex_erreur_evaluation;	if (setjmp(contexte_processus) == 0)
}	{
}	if (variable_partagee == d_faux)
else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	if (((*s_etat_processus).erreur_execution == d_ex) &&
	((*s_etat_processus).erreur_systeme == d_es))
if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') == d_erreur)
{	{
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_evaluation;	d_ex_erreur_evaluation;
}	}
}	}
}	else
}
else
{
if (evaluation(s_etat_processus, s_copie, 'E') == d_erreur)
{
if (((*s_etat_processus).erreur_execution == d_ex) &&
((*s_etat_processus).erreur_systeme == d_es))
{	{
(*s_etat_processus).erreur_execution =	if (((*s_etat_processus).arret_depuis_abort == 0)
d_ex_erreur_evaluation;	&& ((*s_etat_processus).at_exit != NULL))
	{
	(*s_etat_processus).var_volatile_requete_arret = 0;
	(*s_etat_processus).var_volatile_alarme = 0;
	(*s_etat_processus).var_volatile_traitement_sigint
	= 0;

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

	if (evaluation(s_etat_processus,
	(*s_etat_processus).at_exit, 'E') ==
	d_erreur)
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_evaluation;
	}

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus, NULL);
	}
	}
}	}
}	}
else	else
{	{
if ((*s_etat_processus).at_exit != NULL)	if (evaluation(s_etat_processus, (*s), 'E') == d_erreur)
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	if (((*s_etat_processus).erreur_execution == d_ex) &&
	((*s_etat_processus).erreur_systeme == d_es))
if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') == d_erreur)
{	{
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_evaluation;	d_ex_erreur_evaluation;
}	}
}	}
}	else
	{
	if (((*s_etat_processus).arret_depuis_abort == 0)
	&& ((*s_etat_processus).at_exit != NULL))
	{
	(*s_etat_processus).var_volatile_requete_arret = 0;
	(*s_etat_processus).var_volatile_alarme = 0;
	(*s_etat_processus).var_volatile_traitement_sigint
	= 0;

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

	if (evaluation(s_etat_processus,
	(*s_etat_processus).at_exit, 'E') ==
	d_erreur)
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_evaluation;
	}

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

	liberation(s_etat_processus, (*s));
	}
}	}

	free(s);
	}

	for(i = 0; i < (*s_etat_processus).sections_critiques; i++)
	{
	pthread_mutex_unlock(&mutex_sections_critiques);
}	}

liberation(s_etat_processus, (*s_etat_processus).at_exit);	liberation(s_etat_processus, (*s_etat_processus).at_exit);
Line 2146 instruction_detach(struct_processus *s_e	Line 2004 instruction_detach(struct_processus *s_e
l_element_courant = (*s_etat_processus).liste_mutexes;	l_element_courant = (*s_etat_processus).liste_mutexes;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
pthread_mutex_trylock(&((((struct_mutex )
((l_element_courant).donnee).objet)).mutex));
pthread_mutex_unlock(&((((struct_mutex )
((l_element_courant).donnee).objet)).mutex));
pthread_mutex_destroy(&((((struct_mutex )
((l_element_courant).donnee).objet)).mutex));

liberation(s_etat_processus, (*l_element_courant).donnee);	liberation(s_etat_processus, (*l_element_courant).donnee);
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);	free(l_element_courant);
Line 2164 instruction_detach(struct_processus *s_e	Line 2015 instruction_detach(struct_processus *s_e
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}

pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))
{
if (longueur_ecriture == -1)
{
break;
}
}

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2207 instruction_detach(struct_processus *s_e	Line 2048 instruction_detach(struct_processus *s_e
{	{
while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_erreurs[1],	(*s_argument_thread).pipe_erreurs[1],
&((*s_etat_processus).erreur_execution),	(int ) &((s_etat_processus).erreur_execution),
sizeof((*s_etat_processus).erreur_execution))) !=	sizeof((*s_etat_processus).erreur_execution))) !=
sizeof((*s_etat_processus).erreur_execution))	sizeof((*s_etat_processus).erreur_execution))
{	{
Line 2239 instruction_detach(struct_processus *s_e	Line 2080 instruction_detach(struct_processus *s_e
{	{
while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_erreurs[1],	(*s_argument_thread).pipe_erreurs[1],
&((*s_etat_processus).erreur_systeme),	(int ) &((s_etat_processus).erreur_systeme),
sizeof((*s_etat_processus).erreur_systeme))) !=	sizeof((*s_etat_processus).erreur_systeme))) !=
sizeof((*s_etat_processus).erreur_systeme))	sizeof((*s_etat_processus).erreur_systeme))
{	{
Line 2277 instruction_detach(struct_processus *s_e	Line 2118 instruction_detach(struct_processus *s_e
}	}
}	}

close((*s_argument_thread).pipe_erreurs[1]);
close((*s_argument_thread).pipe_interruptions[1]);
close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);
close((*s_argument_thread).pipe_objets[1]);
close((*s_argument_thread).pipe_nombre_objets_attente[1]);
close((*s_argument_thread).pipe_injections[0]);
close((*s_argument_thread).pipe_nombre_injections[0]);
close((*s_argument_thread).pipe_acquittement[0]);

l_element_courant = (*s_etat_processus).s_fichiers;	l_element_courant = (*s_etat_processus).s_fichiers;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 2323 instruction_detach(struct_processus *s_e	Line 2155 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

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

l_element_courant = (struct_liste_chainee *)	l_element_courant = (struct_liste_chainee *)
(*s_etat_processus).l_base_pile_processus;	(*s_etat_processus).l_base_pile_processus;
Line 2363 instruction_detach(struct_processus *s_e	Line 2195 instruction_detach(struct_processus *s_e

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 *)
((l_element_courant).donnee).objet)).thread).pid,	((l_element_courant).donnee).objet)).thread).pid,
SIGURG);	rpl_sigurg, d_faux);
}	}
else	else
{	{
if ((*s_etat_processus).arret_depuis_abort == -1)	if ((*s_etat_processus).arret_depuis_abort == -1)
{	{
kill(((((struct_processus_fils *)	envoi_signal_processus(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.pid, SIGFABORT);	.pid, rpl_sigabort, d_faux);
}	}
else	else
{	{
kill(((((struct_processus_fils *)	envoi_signal_processus(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.pid, SIGFSTOP);	.pid, rpl_sigstop, d_faux);
}	}
}	}
}	}
Line 2421 instruction_detach(struct_processus *s_e	Line 2253 instruction_detach(struct_processus *s_e
{	{
if ((*s_etat_processus).var_volatile_alarme != 0)	if ((*s_etat_processus).var_volatile_alarme != 0)
{	{
pthread_kill(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.tid, SIGURG);	.tid, rpl_sigurg);
}	}
else	else
{	{
if ((*s_etat_processus).arret_depuis_abort == -1)	if ((*s_etat_processus).arret_depuis_abort == -1)
{	{
pthread_kill(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, SIGFABORT);	.thread).tid, rpl_sigabort);
}	}
else	else
{	{
pthread_kill(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, SIGFSTOP);	.thread).tid, rpl_sigstop);
}	}
}	}
}	}
Line 2461 instruction_detach(struct_processus *s_e	Line 2296 instruction_detach(struct_processus *s_e

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

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

Line 2470 instruction_detach(struct_processus *s_e	Line 2303 instruction_detach(struct_processus *s_e
.var_volatile_traitement_retarde_stop;	.var_volatile_traitement_retarde_stop;
(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;	(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;

for(i = 0; i < (unsigned long) ((((struct_processus_fils *)	for(i = 0; i < ((((struct_processus_fils *)
((l_element_courant)	((l_element_courant)
.donnee).objet)).thread).nombre_objets_dans_pipe; i++)	.donnee).objet)).thread).nombre_objets_dans_pipe; i++)
{	{
Line 2483 instruction_detach(struct_processus *s_e	Line 2316 instruction_detach(struct_processus *s_e
((((struct_processus_fils ) ((*l_element_courant)	((((struct_processus_fils ) ((*l_element_courant)
.donnee).objet)).thread).nombre_objets_dans_pipe--;	.donnee).objet)).thread).nombre_objets_dans_pipe--;

	if (pthread_mutex_lock(&mutex_sigaction) != 0)
	{
	destruction_queue_signaux(s_etat_processus);
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}

action.sa_handler = SIG_IGN;	action.sa_handler = SIG_IGN;
action.sa_flags = SA_ONSTACK;	action.sa_flags = 0;

if (sigaction(SIGPIPE, &action, &registre) != 0)	if (sigaction(SIGPIPE, &action, &registre) != 0)
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
	pthread_mutex_unlock(&mutex_sigaction);

if (registre_stop == 0)	if (registre_stop == 0)
{	{
Line 2505 instruction_detach(struct_processus *s_e	Line 2347 instruction_detach(struct_processus *s_e
registre_stop;	registre_stop;
}	}

# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 2543 instruction_detach(struct_processus *s_e	Line 2382 instruction_detach(struct_processus *s_e

if (sigaction(SIGPIPE, &registre, NULL) != 0)	if (sigaction(SIGPIPE, &registre, NULL) != 0)
{	{
# ifdef _BROKEN_SIGINFO	destruction_queue_signaux(s_etat_processus);
destruction_fifos_signaux(s_etat_processus);
# endif

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

	pthread_mutex_unlock(&mutex_sigaction);
	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}

	if (pthread_mutex_unlock(&mutex_sigaction) != 0)
	{
	destruction_queue_signaux(s_etat_processus);
	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}
}	}
}	}

pthread_mutex_unlock(&((*s_etat_processus).mutex));	if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions))
	!= 0)
	{
	destruction_queue_signaux(s_etat_processus);

	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}

if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)	if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
{	{
affectation_interruptions_logicielles(s_etat_processus);	affectation_interruptions_logicielles(s_etat_processus);
}	}

	if (pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_interruptions)) != 0)
	{
	destruction_queue_signaux(s_etat_processus);

	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}

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

	scrutation_interruptions(s_etat_processus);
}	}

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

l_element_courant = (*s_etat_processus).s_sockets;	l_element_courant = (*s_etat_processus).s_sockets;

Line 2664 instruction_detach(struct_processus *s_e	Line 2534 instruction_detach(struct_processus *s_e
(*s_etat_processus).arbre_instructions);	(*s_etat_processus).arbre_instructions);
free((*s_etat_processus).pointeurs_caracteres);	free((*s_etat_processus).pointeurs_caracteres);

	l_element_statique_courant = (*s_etat_processus)
	.l_liste_variables_statiques;

	while(l_element_statique_courant != NULL)
	{
	l_element_statique_suivant = (*l_element_statique_courant).suivant;
	free(l_element_statique_courant);
	l_element_statique_courant = l_element_statique_suivant;
	}

	l_element_partage_courant = ((s_etat_processus)
	.l_liste_variables_partagees);

	while(l_element_partage_courant != NULL)
	{
	l_element_partage_suivant = (*l_element_partage_courant).suivant;
	free(l_element_partage_courant);
	l_element_partage_courant = l_element_partage_suivant;
	}

if ((*s_etat_processus).entree_standard != NULL)	if ((*s_etat_processus).entree_standard != NULL)
{	{
pclose((*s_etat_processus).entree_standard);	pclose((*s_etat_processus).entree_standard);
Line 2688 instruction_detach(struct_processus *s_e	Line 2578 instruction_detach(struct_processus *s_e
(*s_etat_processus).instruction_derniere_erreur = NULL;	(*s_etat_processus).instruction_derniere_erreur = NULL;
}	}

for(i = 0; i < (*s_etat_processus).nombre_variables; i++)	liberation_arbre_variables_partagees(s_etat_processus,
{	((s_etat_processus).s_arbre_variables_partagees));
liberation(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
(*s_etat_processus).s_liste_variables[i].objet);	(*s_etat_processus).s_arbre_variables, d_vrai);
free((*s_etat_processus).s_liste_variables[i].nom);	free((*s_etat_processus).pointeurs_caracteres_variables);
}

free((*s_etat_processus).s_liste_variables);

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
{
liberation(s_etat_processus,
(*s_etat_processus).s_liste_variables_statiques[i].objet);
free((*s_etat_processus).s_liste_variables_statiques[i].nom);
}

free((*s_etat_processus).s_liste_variables_statiques);

for(i = 0; i < ((s_etat_processus).s_liste_variables_partagees)
.nombre_variables; i++)
{
liberation(s_etat_processus,
((s_etat_processus).s_liste_variables_partagees)
.table[i].objet);
free(((s_etat_processus).s_liste_variables_partagees)
.table[i].nom);
}

if (((s_etat_processus).s_liste_variables_partagees).table
!= NULL)
{
free((struct_variable_partagee *)
((s_etat_processus).s_liste_variables_partagees).table);
}

pthread_mutex_destroy(&(((s_etat_processus)
.s_liste_variables_partagees).mutex));

l_element_courant = (*s_etat_processus).l_base_pile;	l_element_courant = (*s_etat_processus).l_base_pile;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 2843 instruction_detach(struct_processus *s_e	Line 2701 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

free((*s_etat_processus).chemin_fichiers_temporaires);

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
if (((*s_etat_processus).type_debug &	if (((*s_etat_processus).type_debug &
d_debug_processus) != 0)	d_debug_processus) != 0)
Line 2896 instruction_detach(struct_processus *s_e	Line 2752 instruction_detach(struct_processus *s_e
liberation_profil(s_etat_processus);	liberation_profil(s_etat_processus);
}	}

	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

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

	while(nombre_threads_surveillance_processus != 0)
	{
	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
	}

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

closelog();	closelog();

liberation_allocateur(s_etat_processus);
retrait_thread(s_etat_processus);	retrait_thread(s_etat_processus);
	liberation_contexte_cas(s_etat_processus);

	clear_history();

	close((*s_argument_thread).pipe_erreurs[1]);
	close((*s_argument_thread).pipe_interruptions[1]);
	close((*s_argument_thread).pipe_nombre_elements_attente[1]);
	close((*s_argument_thread).pipe_objets[1]);
	close((*s_argument_thread).pipe_injections[0]);
	close((*s_argument_thread).pipe_nombre_injections[0]);
	close((*s_argument_thread).pipe_acquittement[0]);

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

	liberation_allocateur(s_etat_processus);
	liberation_allocateur_buffer(s_etat_processus);

	// Permet d'attendre la libération du mutex de la part
	// de surveillance_processus().

	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus))
	== EBUSY)
	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}

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

	// Libération des mutexes.

	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(&((*s_etat_processus).protection_liste_mutexes));	pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
pthread_key_delete(semaphore_fork_processus_courant);	pthread_mutex_destroy(&mutex_sections_critiques);
	pthread_mutex_destroy(&mutex_liste_variables_partagees);

	destruction_queue_signaux(s_etat_processus);
	pthread_mutex_destroy(&mutex_liste_threads);
	pthread_mutex_destroy(&mutex_liste_threads_surveillance);

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

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

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

clear_history();

# ifdef _BROKEN_SIGINFO
destruction_fifos_signaux(s_etat_processus);
# endif	# endif

free(s_etat_processus);	sys_free(s_etat_processus);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE
debug_memoire_verification();	debug_memoire_verification();
analyse_post_mortem();	analyse_post_mortem();
# endif	# endif

	pthread_mutex_destroy(&mutex_sigaction);
exit(EXIT_SUCCESS);	exit(EXIT_SUCCESS);
}	}
else	else
{	{
	deverrouillage_threads_concurrents(s_etat_processus);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 2976 instruction_detach(struct_processus *s_e	Line 2868 instruction_detach(struct_processus *s_e
((l_element_courant).donnee).objet)).thread).pid ==	((l_element_courant).donnee).objet)).thread).pid ==
(*s_argument_thread).pid)	(*s_argument_thread).pid)
{	{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 2985 instruction_detach(struct_processus *s_e	Line 2878 instruction_detach(struct_processus *s_e
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)	if (pthread_mutex_lock(&((*s_etat_processus)
	.mutex_pile_processus)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 2996 instruction_detach(struct_processus *s_e	Line 2890 instruction_detach(struct_processus *s_e
}	}
}	}

	scrutation_interruptions(s_etat_processus);
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}
} while(drapeau == d_vrai);	} while(drapeau == d_vrai);
Line 3004 instruction_detach(struct_processus *s_e	Line 2899 instruction_detach(struct_processus *s_e
(struct_liste_chainee *) &((s_etat_processus)	(struct_liste_chainee *) &((s_etat_processus)
.l_base_pile_processus), s_objet_systeme) == d_erreur)	.l_base_pile_processus), s_objet_systeme) == d_erreur)
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
return;	return;
}	}

if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
s_objet) == d_erreur)	s_objet) == d_erreur)
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
return;	return;
}	}

// Être sûr que le processus fils soit déjà présent...	// On attend une donnée fictive pour être sûr que le segment de mémoire
	// partagée destiné à la gestion des signaux est bien initialisé.

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

while(kill((*s_argument_thread).pid, 0) != 0)	while(read_atomic(s_etat_processus,
	pipe_initialisation_segment_signaux[0],
	&caractere, sizeof(caractere)) == 0)
{	{
//if ((errno != ESRCH) && (errno != EAGAIN))	scrutation_interruptions(s_etat_processus);
if (errno != ESRCH)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&((*s_etat_processus).mutex));
return;
}

nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

// Le fils peut être présent sans être en attente du signal de départ.	close(pipe_initialisation_segment_signaux[0]);
	close(pipe_initialisation_segment_signaux[1]);

if (kill((*s_argument_thread).pid, SIGSTART) != 0)	// Le fils peut être présent sans être en attente du signal de départ.
{
(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&((*s_etat_processus).mutex));
return;
}

if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)	if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart,
	d_vrai) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
return;	return;
}	}

sigpending(&set);	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.49.2.3
changed lines
	Added in v.1.173