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.92 and 1.178

version 1.92, 2012/10/01 11:05:03	version 1.178, 2023/11/22 10:55:15
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.11	RPL/2 (R) version 4.1.35
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2023 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 pipe_initialisation_segment_signaux[2];	int pipe_initialisation_segment_signaux[2];

logical1 drapeau;	logical1 drapeau;

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;

ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;
struct_descripteur_thread *s_argument_thread2;	struct_descripteur_thread *s_argument_thread2;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_chainee *l_element_precedent;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

	struct_liste_variables_partagees *l_element_partage_courant;
	struct_liste_variables_partagees *l_element_partage_suivant;

	struct_liste_variables_statiques *l_element_statique_courant;
	struct_liste_variables_statiques *l_element_statique_suivant;

struct_objet *s_copie;	struct_objet *s_copie;
struct_objet *s_objet;	struct_objet *s_objet;
struct_objet *s_objet_systeme;	struct_objet *s_objet_systeme;
struct_objet *s_objet_temporaire;	struct_objet *s_objet_temporaire;

struct sigaction action;	struct sigaction action;
struct sigaction registre;	struct sigaction registre;

struct timespec attente;	struct timespec attente;

unsigned char caractere;	unsigned char caractere;
unsigned char *message;	unsigned char *message;

unsigned int erreur;	unsigned int erreur;

unsigned long i;	integer8 i;

volatile logical1 variable_partagee;	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 937 instruction_detach(struct_processus *s_e
if (((s_etat_processus).pointeur_variable_courante).objet	if (((s_etat_processus).pointeur_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).pointeur_variable_courante).nom,	((s_etat_processus).pointeur_variable_courante).nom,
((s_etat_processus).pointeur_variable_courante)	((s_etat_processus).pointeur_variable_courante)
.variable_partagee, ((s_etat_processus)	.variable_partagee, ((s_etat_processus)
.pointeur_variable_courante).origine) == d_faux)	.pointeur_variable_courante).origine) == NULL)
{	{
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 959 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 982 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 1002 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 1050 instruction_detach(struct_processus *s_e	Line 1040 instruction_detach(struct_processus *s_e
return;	return;
}	}

if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 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;
Line 1068 instruction_detach(struct_processus *s_e	Line 1058 instruction_detach(struct_processus *s_e
return;	return;
}	}

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

if (pipe((*s_argument_thread).pipe_injections) != 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;
Line 1098 instruction_detach(struct_processus *s_e	Line 1082 instruction_detach(struct_processus *s_e
* Le mutex suivant permet de copier un contexte propre.	* Le mutex suivant permet de copier un contexte propre.
*/	*/

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

	verrouillage_threads_concurrents(s_etat_processus);

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

	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1111 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().
*/	*/

verrouillage_threads_concurrents(s_etat_processus);
(*s_argument_thread).pid = fork();	(*s_argument_thread).pid = fork();
deverrouillage_threads_concurrents(s_etat_processus);
	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation_buffer))
	!= 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 1135 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 1182 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 1195 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 1278 instruction_detach(struct_processus *s_e	Line 1288 instruction_detach(struct_processus *s_e
* Processus fils	* Processus fils
*/	*/

	// EPERM
	#if 0
	pthread_mutex_destroy(&mutex_liste_variables_partagees);
	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);	liberation_queue_signaux(s_etat_processus);
creation_queue_signaux(s_etat_processus);	creation_queue_signaux(s_etat_processus);

routine_recursive = 0;	routine_recursive = 0;
	nombre_threads_surveillance_processus = 0;

(*s_etat_processus).pointeur_signal_lecture = 0;	(*s_etat_processus).pointeur_signal_lecture = 0;
(*s_etat_processus).pointeur_signal_ecriture = 0;	(*s_etat_processus).pointeur_signal_ecriture = 0;
Line 1292 instruction_detach(struct_processus *s_e	Line 1343 instruction_detach(struct_processus *s_e
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
}	}

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

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
Line 1322 instruction_detach(struct_processus *s_e	Line 1372 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 1330 instruction_detach(struct_processus *s_e	Line 1380 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 1376 instruction_detach(struct_processus *s_e	Line 1422 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,	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 1427 instruction_detach(struct_processus *s_e	Line 1454 instruction_detach(struct_processus *s_e
{	{
(*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 1459 instruction_detach(struct_processus *s_e	Line 1474 instruction_detach(struct_processus *s_e
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*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;
}
}

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

pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));

if (pthread_mutex_unlock(&((*s_etat_processus)
.protection_liste_mutexes)) != 0)
{
(*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;
}
}

destruction_queue_signaux(s_etat_processus);
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')
{	{
free((*s_etat_processus).instruction_courante);	free((*s_etat_processus).instruction_courante);
Line 1580 instruction_detach(struct_processus *s_e	Line 1530 instruction_detach(struct_processus *s_e

// Attente de la réception du signal rpl_sigstart.	// Attente de la réception du signal rpl_sigstart.

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

if ((*s_etat_processus).demarrage_fils == d_vrai)
{
break;
}

nanosleep(&attente, NULL);
}	}

(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 1615 instruction_detach(struct_processus *s_e	Line 1558 instruction_detach(struct_processus *s_e
(*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).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 1585 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,	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 1694 instruction_detach(struct_processus *s_e	Line 1629 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 1722 instruction_detach(struct_processus *s_e	Line 1655 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)
{
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 1791 instruction_detach(struct_processus *s_e	Line 1715 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 1844 instruction_detach(struct_processus *s_e	Line 1758 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 1918 instruction_detach(struct_processus *s_e	Line 1822 instruction_detach(struct_processus *s_e
{	{
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;

	// On ne détruit pas le descripteur sous prétexte
	// d'avoir le fichier ou la socket fermée dans le processus père

	/*
fclose((((struct_descripteur_fichier )	fclose((((struct_descripteur_fichier )
(*l_element_courant).donnee)).descripteur_c);	(*l_element_courant).donnee)).descripteur_c);

Line 1927 instruction_detach(struct_processus *s_e	Line 1835 instruction_detach(struct_processus *s_e
sqlite3_close((((struct_descripteur_fichier )	sqlite3_close((((struct_descripteur_fichier )
(*l_element_courant).donnee)).descripteur_sqlite);	(*l_element_courant).donnee)).descripteur_sqlite);
}	}
	*/

free((((struct_descripteur_fichier ) (*l_element_courant)	free((((struct_descripteur_fichier ) (*l_element_courant)
.donnee)).nom);	.donnee)).nom);
Line 1936 instruction_detach(struct_processus *s_e	Line 1845 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 1958 instruction_detach(struct_processus *s_e	Line 1869 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 ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
{	{
Line 2012 instruction_detach(struct_processus *s_e	Line 1921 instruction_detach(struct_processus *s_e
}	}
else	else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))	&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	(*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,	if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') ==	(*s_etat_processus).at_exit, 'E') ==
Line 2025 instruction_detach(struct_processus *s_e	Line 1941 instruction_detach(struct_processus *s_e
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_evaluation;	d_ex_erreur_evaluation;
}	}

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus, NULL);
	}
}	}
}	}
}	}
Line 2041 instruction_detach(struct_processus *s_e	Line 1962 instruction_detach(struct_processus *s_e
}	}
else	else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))	&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	(*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,	if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') ==	(*s_etat_processus).at_exit, 'E') ==
Line 2054 instruction_detach(struct_processus *s_e	Line 1982 instruction_detach(struct_processus *s_e
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_evaluation;	d_ex_erreur_evaluation;
}	}

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

Line 2086 instruction_detach(struct_processus *s_e	Line 2019 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 2129 instruction_detach(struct_processus *s_e	Line 2052 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 2161 instruction_detach(struct_processus *s_e	Line 2084 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 2199 instruction_detach(struct_processus *s_e	Line 2122 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 2245 instruction_detach(struct_processus *s_e	Line 2159 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 2287 instruction_detach(struct_processus *s_e	Line 2201 instruction_detach(struct_processus *s_e
{	{
envoi_signal_processus(((((struct_processus_fils *)	envoi_signal_processus(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread).pid,	((l_element_courant).donnee).objet)).thread).pid,
rpl_sigurg);	rpl_sigurg, d_faux);
}	}
else	else
{	{
Line 2295 instruction_detach(struct_processus *s_e	Line 2209 instruction_detach(struct_processus *s_e
{	{
envoi_signal_processus(((((struct_processus_fils *)	envoi_signal_processus(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.pid, rpl_sigabort);	.pid, rpl_sigabort, d_faux);
}	}
else	else
{	{
envoi_signal_processus(((((struct_processus_fils *)	envoi_signal_processus(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.pid, rpl_sigstop);	.pid, rpl_sigstop, d_faux);
}	}
}	}
}	}
Line 2343 instruction_detach(struct_processus *s_e	Line 2257 instruction_detach(struct_processus *s_e
{	{
if ((*s_etat_processus).var_volatile_alarme != 0)	if ((*s_etat_processus).var_volatile_alarme != 0)
{	{
envoi_signal_thread(((((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, rpl_sigurg);	.tid, rpl_sigurg);
}	}
Line 2351 instruction_detach(struct_processus *s_e	Line 2266 instruction_detach(struct_processus *s_e
{	{
if ((*s_etat_processus).arret_depuis_abort == -1)	if ((*s_etat_processus).arret_depuis_abort == -1)
{	{
envoi_signal_thread(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, rpl_sigabort);	.thread).tid, rpl_sigabort);
}	}
else	else
{	{
envoi_signal_thread(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, rpl_sigstop);	.thread).tid, rpl_sigstop);
}	}
Line 2390 instruction_detach(struct_processus *s_e	Line 2307 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 2403 instruction_detach(struct_processus *s_e	Line 2320 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 2462 instruction_detach(struct_processus *s_e	Line 2388 instruction_detach(struct_processus *s_e
{	{
destruction_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

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);	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 2490 instruction_detach(struct_processus *s_e	Line 2448 instruction_detach(struct_processus *s_e
{	{
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;

if ((((struct_socket ) ((l_element_courant).donnee)
.objet)).socket_connectee == d_vrai)
{
shutdown((((struct_socket ) ((l_element_courant).donnee)
.objet)).socket, SHUT_RDWR);
}

close((((struct_socket ) ((l_element_courant).donnee)
.objet)).socket);

if (((((struct_socket ) ((l_element_courant).donnee).objet))	if (((((struct_socket ) ((l_element_courant).donnee).objet))
.pid == getpid()) && (pthread_equal((((struct_socket )	.pid == getpid()) && (pthread_equal((((struct_socket )
((l_element_courant).donnee).objet)).tid, pthread_self())	((l_element_courant).donnee).objet)).tid, pthread_self())
!= 0))	!= 0))
{	{
	if ((((struct_socket ) ((l_element_courant).donnee)
	.objet)).socket_connectee == d_vrai)
	{
	shutdown((((struct_socket ) ((l_element_courant).donnee)
	.objet)).socket, SHUT_RDWR);
	}

	close((((struct_socket ) ((l_element_courant).donnee)
	.objet)).socket);

if ((((struct_socket ) ((l_element_courant).donnee).objet))	if ((((struct_socket ) ((l_element_courant).donnee).objet))
.effacement == 'Y')	.effacement == 'Y')
{	{
Line 2580 instruction_detach(struct_processus *s_e	Line 2538 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 2604 instruction_detach(struct_processus *s_e	Line 2582 instruction_detach(struct_processus *s_e
(*s_etat_processus).instruction_derniere_erreur = NULL;	(*s_etat_processus).instruction_derniere_erreur = NULL;
}	}

	liberation_arbre_variables_partagees(s_etat_processus,
	((s_etat_processus).s_arbre_variables_partagees));
liberation_arbre_variables(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
(*s_etat_processus).s_arbre_variables, d_vrai);	(*s_etat_processus).s_arbre_variables, d_vrai);
free((*s_etat_processus).pointeurs_caracteres_variables);	free((*s_etat_processus).pointeurs_caracteres_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 2754 instruction_detach(struct_processus *s_e	Line 2705 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 2807 instruction_detach(struct_processus *s_e	Line 2756 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_unlock(&((*s_etat_processus).mutex_pile_processus));

pthread_mutex_destroy(&((*s_etat_processus).mutex));	// 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_mutex_destroy(&mutex_sections_critiques);	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));
Line 2826 instruction_detach(struct_processus *s_e	Line 2832 instruction_detach(struct_processus *s_e
pthread_self(), SEM_FORK);	pthread_self(), SEM_FORK);
# endif	# endif

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

clear_history();

destruction_queue_signaux(s_etat_processus);
liberation_contexte_cas(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
{	{
	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 2871 instruction_detach(struct_processus *s_e	Line 2872 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 2880 instruction_detach(struct_processus *s_e	Line 2882 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 2900 instruction_detach(struct_processus *s_e	Line 2903 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;
}	}

Line 2927 instruction_detach(struct_processus *s_e	Line 2930 instruction_detach(struct_processus *s_e
}	}

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

// Le fils peut être présent sans être en attente du signal de départ.	// Le fils peut être présent sans être en attente du signal de départ.

if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 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;
}	}

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;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.92
changed lines
	Added in v.1.178