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.24 and 1.173

version 1.24, 2010/06/02 10:28:45	version 1.173, 2020/01/10 11:15:44
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.16	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2010 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 20	Line 20
*/	*/


#include "rpl.conv.h"	#include "rpl-conv.h"


/*	/*
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_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 930 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 965 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 988 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 1008 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 1016 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 1040 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 1153 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 1171 instruction_detach(struct_processus *s_e	Line 1133 instruction_detach(struct_processus *s_e
pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);	pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

if ((*s_argument_thread).pid > 0)	if ((*s_argument_thread).pid > 0)
{	{
/*	/*
* 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);
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	liberation(s_etat_processus, s_objet);

	if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	(((struct_processus_fils ) (*s_objet).objet)).thread =
	s_argument_thread;
	((((struct_processus_fils ) (s_objet).objet)).thread)
	.nombre_objets_dans_pipe = 0;
	((((struct_processus_fils ) (s_objet).objet)).thread)
	.nombre_interruptions_dans_pipe = 0;
	((((struct_processus_fils ) (s_objet).objet)).thread)
	.nombre_references = 1;

	/*
	* On copie l'objet plutôt que le pointeur car cet objet peut être
	* accédé depuis deux threads distincts et aboutir à un blocage lors
	* d'une copie.
	*/

	if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet, 'O'))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

Line 1206 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 1219 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 1256 instruction_detach(struct_processus *s_e	Line 1242 instruction_detach(struct_processus *s_e
return;	return;
}	}

	# ifdef SCHED_OTHER
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

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

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

# ifndef SEMAPHORES_NOMMES	// EPERM
sem_post(&semaphore_gestionnaires_signaux);	#if 0
sem_destroy(&semaphore_gestionnaires_signaux);	pthread_mutex_destroy(&mutex_liste_variables_partagees);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);	pthread_mutex_destroy(&mutex_liste_threads);
# else	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus);
sem_post(semaphore_gestionnaires_signaux);	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
sem_destroy2(semaphore_gestionnaires_signaux,	#endif
sem_gestionnaires_signaux);	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);

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

# ifndef SEMAPHORES_NOMMES	routine_recursive = 0;
sem_post(&semaphore_liste_threads);	nombre_threads_surveillance_processus = 0;
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,	(*s_etat_processus).pointeur_signal_lecture = 0;
sem_liste_threads)) == SEM_FAILED)	(*s_etat_processus).pointeur_signal_ecriture = 0;
{
(*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,	if (write_atomic(s_etat_processus,
sem_gestionnaires_signaux_atomique)) == SEM_FAILED)	pipe_initialisation_segment_signaux[1],
	"-", sizeof(unsigned char)) != sizeof(unsigned char))
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}

sem_trywait((*s_etat_processus).semaphore_fork);	close(pipe_initialisation_segment_signaux[0]);
# endif	close(pipe_initialisation_segment_signaux[1]);

# ifndef SEMAPHORES_NOMMES	if ((*s_etat_processus).debug == d_vrai)
if (pthread_setspecific(semaphore_fork_processus_courant,	if (((*s_etat_processus).type_debug &
&((*s_etat_processus).semaphore_fork)) != 0)	d_debug_processus) != 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 ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Lancement du processus fils %d de %d\n",
	(int) getpid(), (int) getpid(), (int) ppid);
	}
	else
	{
	printf("[%d] Start child process %d from %d\n", (int) getpid(),
	(int) getpid(), (int) ppid);
	}

	fflush(stdout);
}	}

if (close((*s_argument_thread).pipe_erreurs[0]) != 0)	if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
Line 1364 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 1372 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 1389 instruction_detach(struct_processus *s_e	Line 1394 instruction_detach(struct_processus *s_e
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}

	if ((*s_etat_processus).debug == d_vrai)
	if (((*s_etat_processus).type_debug &
	d_debug_processus) != 0)
	{
	if ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Libération des objets du processus père\n",
	(int) getpid());
	}
	else
	{
	printf("[%d] Freeing parent process memory\n", getpid());
	}

	fflush(stdout);
	}

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 1408 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 1450 instruction_detach(struct_processus *s_e	Line 1446 instruction_detach(struct_processus *s_e
}	}
}	}

	destruction_queue_signaux(s_etat_processus);
	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,	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)
{
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)	if (longueur_ecriture == -1)
{	{
Line 1479 instruction_detach(struct_processus *s_e	Line 1465 instruction_detach(struct_processus *s_e
}	}
}	}

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

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

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;
}
}

exit(EXIT_FAILURE);
}

if ((*s_etat_processus).evaluation_expression_compilee == 'N')	if ((*s_etat_processus).evaluation_expression_compilee == 'N')
{	{
Line 1519 instruction_detach(struct_processus *s_e	Line 1482 instruction_detach(struct_processus *s_e
}	}

(*s_etat_processus).var_volatile_processus_pere = 0;	(*s_etat_processus).var_volatile_processus_pere = 0;
	(*s_etat_processus).var_volatile_processus_racine = 0;

// On réinitialise toutes les interruptions.	// On réinitialise toutes les interruptions.

Line 1530 instruction_detach(struct_processus *s_e	Line 1494 instruction_detach(struct_processus *s_e

liberation(s_etat_processus, (*s_etat_processus).at_exit);	liberation(s_etat_processus, (*s_etat_processus).at_exit);
(*s_etat_processus).at_exit = NULL;	(*s_etat_processus).at_exit = NULL;
	liberation(s_etat_processus, (*s_etat_processus).at_poke);
	(*s_etat_processus).at_poke = NULL;
	(*s_etat_processus).traitement_at_poke = 'N';

for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
{	{
Line 1554 instruction_detach(struct_processus *s_e	Line 1521 instruction_detach(struct_processus *s_e
(*s_etat_processus).pile_origine_interruptions[i] = NULL;	(*s_etat_processus).pile_origine_interruptions[i] = NULL;
}	}

if ((*s_etat_processus).debug == d_vrai)
if (((*s_etat_processus).type_debug &
d_debug_processus) != 0)
{
if ((*s_etat_processus).langue == 'F')
{
printf("[%d] Lancement du processus fils %d de %d\n",
(int) getpid(), (int) getpid(), (int) ppid);
}
else
{
printf("[%d] Start child process %d from %d\n", (int) getpid(),
(int) getpid(), (int) ppid);
}

fflush(stdout);
}

/*	/*
* On bloque l'exécution du processus fils jusqu'à ce que	* On bloque l'exécution du processus fils jusqu'à ce que
* le père ait renseigné correctement la pile des processus.	* le père ait renseigné correctement la pile des processus.
Line 1580 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 1619 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 1641 instruction_detach(struct_processus *s_e	Line 1582 instruction_detach(struct_processus *s_e
}	}

/*	/*
* Initialisation de la pile des processus	* Initialisation de la pile des processus. Cette pile est effacée
	* par liberation_threads().
*/	*/

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

	caractere = 0;

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

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

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;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
l_element_suivant = (*l_element_courant).suivant;	s_argument_thread2 = (struct_descripteur_thread *)
	(((struct_processus_fils ) ((l_element_courant).donnee)
	.objet)).thread;

	(*s_argument_thread2).nombre_references--;

if (((((struct_processus_fils ) ((*l_element_courant).donnee)	BUG((*s_argument_thread2).nombre_references < 0,
.objet)).thread).processus_detache == d_faux)	destruction_queue_signaux(s_etat_processus),
	printf("(*s_argument_thread2).nombre_references = %d\n",
	(int) (*s_argument_thread2).nombre_references));

	if ((*s_argument_thread2).nombre_references == 0)
{	{
liberation(s_etat_processus, ((((struct_processus_fils *)	close((*s_argument_thread2).pipe_objets[0]);
((l_element_courant).donnee).objet)).thread)	close((*s_argument_thread2).pipe_acquittement[1]);
.argument);	close((*s_argument_thread2).pipe_injections[1]);
}	close((*s_argument_thread2).pipe_nombre_injections[1]);
	close((*s_argument_thread2).pipe_nombre_elements_attente[0]);
	close((*s_argument_thread2).pipe_interruptions[0]);

free(((l_element_courant).donnee).objet);	pthread_mutex_destroy(&((*s_argument_thread2).mutex));
free((*l_element_courant).donnee);
free(l_element_courant);

	if ((*s_argument_thread2).processus_detache == d_faux)
	{
	if ((*s_argument_thread2).destruction_objet == d_vrai)
	{
	liberation(s_etat_processus,
	(*s_argument_thread2).argument);
	}
	}

	free(s_argument_thread2);
	free(((l_element_courant).donnee).objet);
	free((*l_element_courant).donnee);
	}

	l_element_suivant = (*l_element_courant).suivant;
	free((struct_liste_chainee *) l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

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

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

	caractere = 0;

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

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

/*	/*
* Initialisation de la pile système	* Initialisation de la pile système
*/	*/
Line 1706 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 1728 instruction_detach(struct_processus *s_e	Line 1728 instruction_detach(struct_processus *s_e
}	}
}	}

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

Line 1757 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)
{
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)	if (longueur_ecriture == -1)
{	{
Line 1779 instruction_detach(struct_processus *s_e	Line 1771 instruction_detach(struct_processus *s_e
}	}
}	}

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

Line 1847 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 1869 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)	if ((*s_etat_processus).debug == d_vrai)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (((*s_etat_processus).type_debug & d_debug_processus)
	!= 0)
	{
	if ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Évaluation de l'objet détaché\n", getpid());
	}
	else
	{
	printf("[%d] Évaluation of detached object\n", getpid());
	}
	}
}	}

sigpending(&set);

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;

liberation(s_etat_processus, s_copie);	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);
	}
	}
	}

	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);
	liberation(s_etat_processus, (*s_etat_processus).at_poke);

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 1968 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,	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)
{
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)	if (longueur_ecriture == -1)
{	{
Line 2011 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 2043 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 2081 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 2127 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 2167 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 2225 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 2265 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 2274 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 2287 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 2309 instruction_detach(struct_processus *s_e	Line 2347 instruction_detach(struct_processus *s_e
registre_stop;	registre_stop;
}	}

	destruction_queue_signaux(s_etat_processus);
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 2343 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)
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));	destruction_queue_signaux(s_etat_processus);

	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 2460 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 2484 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 2639 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 2659 instruction_detach(struct_processus *s_e	Line 2719 instruction_detach(struct_processus *s_e

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

# ifndef Cygwin
(*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;
sigaltstack(&((*s_etat_processus).pile_signal), NULL);
free((*s_etat_processus).pile_signal.ss_sp);
# endif

free((*s_etat_processus).definitions_chainees);	free((*s_etat_processus).definitions_chainees);
free((*s_etat_processus).nom_fichier_historique);	free((*s_etat_processus).nom_fichier_historique);

Line 2698 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);

pthread_mutex_destroy(&((*s_etat_processus).mutex));	clear_history();
pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));

pthread_key_delete(semaphore_fork_processus_courant);

# ifndef SEMAPHORES_NOMMES	close((*s_argument_thread).pipe_erreurs[1]);
sem_post(&((*s_etat_processus).semaphore_fork));	close((*s_argument_thread).pipe_interruptions[1]);
sem_destroy(&((*s_etat_processus).semaphore_fork));	close((*s_argument_thread).pipe_nombre_elements_attente[1]);
# else	close((*s_argument_thread).pipe_objets[1]);
sem_post((*s_etat_processus).semaphore_fork);	close((*s_argument_thread).pipe_injections[0]);
sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);	close((*s_argument_thread).pipe_nombre_injections[0]);
# endif	close((*s_argument_thread).pipe_acquittement[0]);

free((*s_etat_processus).localisation);	free((*s_etat_processus).localisation);
	free((*s_etat_processus).chemin_fichiers_temporaires);
free(s_argument_thread);	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_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_interruptions));
	pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
	pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
	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_destroy(&semaphore_liste_threads);	sem_post(&((*s_etat_processus).semaphore_fork));
sem_post(&semaphore_gestionnaires_signaux);	sem_destroy(&((*s_etat_processus).semaphore_fork));
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux_atomique);
# else	# else
sem_destroy2(semaphore_liste_threads, sem_liste_threads);	sem_post((*s_etat_processus).semaphore_fork);
sem_post(semaphore_gestionnaires_signaux);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
sem_destroy2(semaphore_gestionnaires_signaux,	pthread_self(), SEM_FORK);
sem_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux_atomique,
sem_gestionnaires_signaux_atomique);
# endif	# endif

clear_history();	sys_free(s_etat_processus);

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

liberation(s_etat_processus, s_objet);

if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;
}

(((struct_processus_fils ) (*s_objet).objet)).thread = s_argument_thread;
((((struct_processus_fils ) (s_objet).objet)).thread)
.nombre_objets_dans_pipe = 0;
((((struct_processus_fils ) (s_objet).objet)).thread)
.nombre_interruptions_dans_pipe = 0;
((((struct_processus_fils ) (s_objet).objet)).thread)
.nombre_references = 1;

/*
* On copie l'objet plutôt que le pointeur car cet objet peut être
* accédé depuis deux threads distincts et aboutir à un blocage lors d'une
* copie.
*/

if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;
}

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 2807 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 2816 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 2827 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 2835 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é.

while(kill((*s_argument_thread).pid, 0) != 0)	attente.tv_sec = 0;
{	attente.tv_nsec = GRANULARITE_us * 1000;
//if ((errno != ESRCH) && (errno != EAGAIN))
if (errno != ESRCH)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&((*s_etat_processus).mutex));
return;
}

	while(read_atomic(s_etat_processus,
	pipe_initialisation_segment_signaux[0],
	&caractere, sizeof(caractere)) == 0)
	{
	scrutation_interruptions(s_etat_processus);
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
	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.24
changed lines
	Added in v.1.173