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.28 and 1.157

version 1.28, 2010/06/18 08:30:50	version 1.157, 2017/06/28 09:20:33
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.16	RPL/2 (R) version 4.1.27
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2017 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;	#ifndef EXPERIMENTAL_CODE
	printf("DETACH currently broken is replaced by SPAWN...\n");
	instruction_spawn(s_etat_processus);
	#else
	int pipe_initialisation_segment_signaux[2];

logical1 drapeau;	logical1 drapeau;
logical1 variable_partagee;

pid_t ppid;	pid_t ppid;
pid_t pid_final;

pthread_attr_t attributs;	pthread_attr_t attributs;

pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;

pthread_t thread_surveillance;	pthread_t thread_surveillance;

sig_atomic_t registre_stop;	sig_atomic_t registre_stop;

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

ssize_t longueur_ecriture;	struct_descripteur_thread *s_argument_thread;
	struct_descripteur_thread *s_argument_thread2;

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

struct_liste_chainee *l_element_courant;	struct_liste_variables_partagees *l_element_partage_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_variables_partagees *l_element_partage_suivant;
struct_liste_chainee *l_element_suivant;
	struct_liste_variables_statiques *l_element_statique_courant;
	struct_liste_variables_statiques *l_element_statique_suivant;

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

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

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

struct timespec attente;	unsigned char caractere;
	unsigned char *message;

unsigned char *message;	unsigned int erreur;

unsigned int erreur;	integer8 i;

unsigned long i;	volatile logical1 variable_partagee;

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

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

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

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

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

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

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

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

Line 1041 instruction_detach(struct_processus *s_e	Line 1026 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;
return;
}

/*
* 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_erreurs) != 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_interruptions) != 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_nombre_elements_attente) != 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_objets) != 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_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_interruptions) != 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_nombre_interruptions_attente) != 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_objets) != 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_acquittement) != 0)	ppid = getpid();
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 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_injections) != 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_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();	verrouillage_threads_concurrents(s_etat_processus);

/*
* 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_allocation_buffer)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1154 instruction_detach(struct_processus *s_e	Line 1113 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 1172 instruction_detach(struct_processus *s_e	Line 1137 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);
Line 1225 instruction_detach(struct_processus *s_e	Line 1202 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 1238 instruction_detach(struct_processus *s_e	Line 1215 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 1275 instruction_detach(struct_processus *s_e	Line 1246 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 1315 instruction_detach(struct_processus *s_e	Line 1292 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_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 0
	liberation_queue_signaux(s_etat_processus);
	#endif
	creation_queue_signaux(s_etat_processus);

	routine_recursive = 0;
	nombre_thread_surveillance_processus = 0;

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

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

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

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
if (((*s_etat_processus).type_debug &	if (((*s_etat_processus).type_debug &
d_debug_processus) != 0)	d_debug_processus) != 0)
Line 1333 instruction_detach(struct_processus *s_e	Line 1362 instruction_detach(struct_processus *s_e
fflush(stdout);	fflush(stdout);
}	}

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

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

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

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

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

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

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

# ifndef SEMAPHORES_NOMMES
if (pthread_setspecific(semaphore_fork_processus_courant,
&((*s_etat_processus).semaphore_fork)) != 0)
# else
if (pthread_setspecific(semaphore_fork_processus_courant,
(*s_etat_processus).semaphore_fork) != 0)
# endif
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

if (close((*s_argument_thread).pipe_erreurs[0]) != 0)	if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1401 instruction_detach(struct_processus *s_e	Line 1371 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 1409 instruction_detach(struct_processus *s_e	Line 1379 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 1446 instruction_detach(struct_processus *s_e	Line 1412 instruction_detach(struct_processus *s_e
l_element_courant = (*s_etat_processus).liste_mutexes;	l_element_courant = (*s_etat_processus).liste_mutexes;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
pthread_mutex_trylock(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));
pthread_mutex_unlock(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));
pthread_mutex_destroy(&((((struct_mutex ) ((l_element_courant)
.donnee).objet)).mutex));

liberation(s_etat_processus, (*l_element_courant).donnee);	liberation(s_etat_processus, (*l_element_courant).donnee);
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);	free(l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}
	#endif

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

	#if 0
liberation_threads(s_etat_processus);	liberation_threads(s_etat_processus);
	#endif
((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));	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
(*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)	if (longueur_ecriture == -1)
{	{
Line 1494 instruction_detach(struct_processus *s_e	Line 1448 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);
	}

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

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 1504 instruction_detach(struct_processus *s_e	Line 1468 instruction_detach(struct_processus *s_e
}	}
}	}

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

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

	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;

pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1524 instruction_detach(struct_processus *s_e	Line 1496 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);
	}

	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;

	caractere = 0;

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 1534 instruction_detach(struct_processus *s_e	Line 1520 instruction_detach(struct_processus *s_e
}	}
}	}

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

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

if (pthread_mutex_unlock(&((*s_etat_processus)	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))
.protection_liste_mutexes)) != 0)	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;

pid_final = -2;	caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&pid_final, sizeof(pid_final))) != sizeof(pid_final))	&caractere, sizeof(caractere))) != sizeof(caractere))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 1557 instruction_detach(struct_processus *s_e	Line 1544 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);
	}

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

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

	caractere = 0;

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 1567 instruction_detach(struct_processus *s_e	Line 1568 instruction_detach(struct_processus *s_e
}	}
}	}

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

if ((*s_etat_processus).evaluation_expression_compilee == 'N')	if ((*s_etat_processus).evaluation_expression_compilee == 'N')
{	{
	#if 0
free((*s_etat_processus).instruction_courante);	free((*s_etat_processus).instruction_courante);
	#endif
(*s_etat_processus).instruction_courante = NULL;	(*s_etat_processus).instruction_courante = NULL;
}	}

	#if 0
(*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 1589 instruction_detach(struct_processus *s_e	Line 1595 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';
	#endif

for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
{	{
	#if 0
liberation(s_etat_processus,	liberation(s_etat_processus,
(*s_etat_processus).corps_interruptions[i]);	(*s_etat_processus).corps_interruptions[i]);
	#endif

(*s_etat_processus).corps_interruptions[i] = NULL;	(*s_etat_processus).corps_interruptions[i] = NULL;
(*s_etat_processus).masque_interruptions[i] = 'N';	(*s_etat_processus).masque_interruptions[i] = 'N';
(*s_etat_processus).queue_interruptions[i] = 0;	(*s_etat_processus).queue_interruptions[i] = 0;

	#if 0
l_element_courant = (*s_etat_processus)	l_element_courant = (*s_etat_processus)
.pile_origine_interruptions[i];	.pile_origine_interruptions[i];

Line 1609 instruction_detach(struct_processus *s_e	Line 1622 instruction_detach(struct_processus *s_e
free(l_element_courant);	free(l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}
	#endif

(*s_etat_processus).pile_origine_interruptions[i] = NULL;	(*s_etat_processus).pile_origine_interruptions[i] = NULL;
}	}
Line 1621 instruction_detach(struct_processus *s_e	Line 1635 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);
}	}

	#if 0
(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 1660 instruction_detach(struct_processus *s_e	Line 1665 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;
	#endif

	#if 0
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
liberation_profil(s_etat_processus);	liberation_profil(s_etat_processus);
}	}
	#endif

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

	#if 0
if ((*s_etat_processus).generateur_aleatoire != NULL)	if ((*s_etat_processus).generateur_aleatoire != NULL)
{	{
liberation_generateur_aleatoire(s_etat_processus);	liberation_generateur_aleatoire(s_etat_processus);
}	}
	#endif

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

Line 1686 instruction_detach(struct_processus *s_e	Line 1698 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 1712 instruction_detach(struct_processus *s_e	Line 1715 instruction_detach(struct_processus *s_e
}	}
}	}

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

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

	#if 0
if ((*s_argument_thread2).nombre_references == 0)	if ((*s_argument_thread2).nombre_references == 0)
{	{
close((*s_argument_thread2).pipe_objets[0]);	close((*s_argument_thread2).pipe_objets[0]);
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 1757 instruction_detach(struct_processus *s_e	Line 1761 instruction_detach(struct_processus *s_e
free(((l_element_courant).donnee).objet);	free(((l_element_courant).donnee).objet);
free((*l_element_courant).donnee);	free((*l_element_courant).donnee);
}	}
	#endif

l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free((struct_liste_chainee *) l_element_courant);	free((struct_liste_chainee *) l_element_courant);
Line 1765 instruction_detach(struct_processus *s_e	Line 1770 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,
(*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 1791 instruction_detach(struct_processus *s_e	Line 1787 instruction_detach(struct_processus *s_e
}	}
}	}

	destruction_queue_signaux(s_etat_processus);
BUG(1, uprintf("Process management error line %d\n", __LINE__));	BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
Line 1799 instruction_detach(struct_processus *s_e	Line 1796 instruction_detach(struct_processus *s_e
* Initialisation de la pile système	* Initialisation de la pile système
*/	*/

	#if 0
l_element_courant = (struct_liste_chainee *)	l_element_courant = (struct_liste_chainee *)
(*s_etat_processus).l_base_pile_systeme;	(*s_etat_processus).l_base_pile_systeme;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 1825 instruction_detach(struct_processus *s_e	Line 1823 instruction_detach(struct_processus *s_e

l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}
	#endif

(*s_etat_processus).l_base_pile_systeme = NULL;	(*s_etat_processus).l_base_pile_systeme = NULL;
(*s_etat_processus).hauteur_pile_systeme = 0;	(*s_etat_processus).hauteur_pile_systeme = 0;

	#if 0
empilement_pile_systeme(s_etat_processus);	empilement_pile_systeme(s_etat_processus);

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 1855 instruction_detach(struct_processus *s_e	Line 1845 instruction_detach(struct_processus *s_e
}	}
}	}

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

((s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';	((s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
	#endif

	#if 0
l_element_courant = (struct_liste_chainee *)	l_element_courant = (struct_liste_chainee *)
(*s_etat_processus).s_marques;	(*s_etat_processus).s_marques;

Line 1873 instruction_detach(struct_processus *s_e	Line 1866 instruction_detach(struct_processus *s_e
free((struct_marque *) l_element_courant);	free((struct_marque *) l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}
	#endif

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

Line 1881 instruction_detach(struct_processus *s_e	Line 1875 instruction_detach(struct_processus *s_e
* les variables dans le cas d'un programme compilé.	* les variables dans le cas d'un programme compilé.
*/	*/

	#if 0
empilement_pile_systeme(s_etat_processus);	empilement_pile_systeme(s_etat_processus);

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 1907 instruction_detach(struct_processus *s_e	Line 1892 instruction_detach(struct_processus *s_e
}	}
}	}

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

((s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';	((s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
	#endif

/*	/*
* Destruction des sorties graphiques et PostScript	* Destruction des sorties graphiques et PostScript
*/	*/

	#if 0
while((*s_etat_processus).fichiers_graphiques != NULL)	while((*s_etat_processus).fichiers_graphiques != NULL)
{	{
free(((s_etat_processus).fichiers_graphiques).nom);	free(((s_etat_processus).fichiers_graphiques).nom);
Line 1938 instruction_detach(struct_processus *s_e	Line 1926 instruction_detach(struct_processus *s_e
pclose((*s_etat_processus).entree_standard);	pclose((*s_etat_processus).entree_standard);
(*s_etat_processus).entree_standard = NULL;	(*s_etat_processus).entree_standard = NULL;
}	}
	#endif

(*s_etat_processus).requete_nouveau_plan = d_vrai;	(*s_etat_processus).requete_nouveau_plan = d_vrai;
(*s_etat_processus).mise_a_jour_trace_requise = d_faux;	(*s_etat_processus).mise_a_jour_trace_requise = d_faux;
Line 1952 instruction_detach(struct_processus *s_e	Line 1941 instruction_detach(struct_processus *s_e
* Destruction des piles de fichiers	* Destruction des piles de fichiers
*/	*/

	#if 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 1976 instruction_detach(struct_processus *s_e	Line 1966 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 1998 instruction_detach(struct_processus *s_e	Line 1990 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;
	#endif
if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

sigpending(&set);

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
{	{
Line 2030 instruction_detach(struct_processus *s_e	Line 2014 instruction_detach(struct_processus *s_e
}	}
}	}

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

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

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

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

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

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

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

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

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

	free(s);
	}
	#endif

	#if 0
	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 2112 instruction_detach(struct_processus *s_e	Line 2143 instruction_detach(struct_processus *s_e
{	{
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}
	#endif

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 2156 instruction_detach(struct_processus *s_e	Line 2178 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 2188 instruction_detach(struct_processus *s_e	Line 2210 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 2226 instruction_detach(struct_processus *s_e	Line 2248 instruction_detach(struct_processus *s_e
}	}
}	}

close((*s_argument_thread).pipe_erreurs[1]);	#if 0
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 2272 instruction_detach(struct_processus *s_e	Line 2286 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 2312 instruction_detach(struct_processus *s_e	Line 2326 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 2370 instruction_detach(struct_processus *s_e	Line 2384 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(((((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(((((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(((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, SIGFSTOP);	.thread).tid, rpl_sigstop);
}	}
}	}
}	}
Line 2410 instruction_detach(struct_processus *s_e	Line 2424 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 2419 instruction_detach(struct_processus *s_e	Line 2431 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 2437 instruction_detach(struct_processus *s_e	Line 2449 instruction_detach(struct_processus *s_e

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

if (registre_stop == 0)	if (registre_stop == 0)
{	{
Line 2454 instruction_detach(struct_processus *s_e	Line 2467 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 2488 instruction_detach(struct_processus *s_e	Line 2502 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(&((*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);
}	}
}	}
}	}

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 2605 instruction_detach(struct_processus *s_e	Line 2644 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 2629 instruction_detach(struct_processus *s_e	Line 2688 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 2784 instruction_detach(struct_processus *s_e	Line 2811 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 2804 instruction_detach(struct_processus *s_e	Line 2829 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 2843 instruction_detach(struct_processus *s_e	Line 2862 instruction_detach(struct_processus *s_e
liberation_profil(s_etat_processus);	liberation_profil(s_etat_processus);
}	}

closelog();	#endif
	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

liberation_allocateur(s_etat_processus);	while(nombre_thread_surveillance_processus != 0)
retrait_thread(s_etat_processus);	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}

pthread_mutex_destroy(&((*s_etat_processus).mutex));	#if 0
pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));	closelog();

pthread_key_delete(semaphore_fork_processus_courant);	retrait_thread(s_etat_processus);
	liberation_contexte_cas(s_etat_processus);
	#endif
	destruction_queue_signaux(s_etat_processus);

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

	#if 0
	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).localisation);
	free((*s_etat_processus).chemin_fichiers_temporaires);
free(s_argument_thread);	free(s_argument_thread);

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

clear_history();	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);
	pthread_mutex_destroy(&mutex_liste_threads);

free(s_etat_processus);	sys_free(s_etat_processus);

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

exit(EXIT_SUCCESS);	exit(EXIT_SUCCESS);
}	}
Line 2918 instruction_detach(struct_processus *s_e	Line 2956 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 2927 instruction_detach(struct_processus *s_e	Line 2966 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 2938 instruction_detach(struct_processus *s_e	Line 2978 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 2946 instruction_detach(struct_processus *s_e	Line 2987 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;
}	}

return;	return;
	#endif
}	}

// vim: ts=4	// vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.28
changed lines
	Added in v.1.157