rpl/src/gestion_threads.c - diff

Return to gestion_threads.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_threads.c between versions 1.12 and 1.83

version 1.12, 2010/04/28 07:05:38	version 1.83, 2013/05/30 09:41:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.15	RPL/2 (R) version 4.1.14
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2013 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 38	Line 38
void *	void *
lancement_thread(void *argument)	lancement_thread(void *argument)
{	{
int status;	int status;

pid_t ppid;	pid_t ppid;

pthread_t tid_final;	sig_atomic_t registre_stop;

sig_atomic_t registre_stop;	ssize_t longueur_ecriture;

sigset_t set;	struct_descripteur_thread *s_argument_thread;

ssize_t longueur_ecriture;	struct_liste_chainee *l_element_courant;
	struct_liste_chainee *l_element_suivant;

struct_descripteur_thread *s_argument_thread;	struct_liste_variables_statiques *l_element_statique_courant;
	struct_liste_variables_statiques *l_element_statique_suivant;

struct_liste_chainee *l_element_courant;	struct_objet *s_objet_temporaire;
struct_liste_chainee *l_element_suivant;

struct_objet *s_objet_temporaire;	struct_processus *s_etat_processus;

struct_processus *s_etat_processus;	struct sigaction action;
	struct sigaction registre;

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;

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

s_argument_thread = (struct_descripteur_thread *) argument;	s_argument_thread = (struct_descripteur_thread *) argument;
(*s_argument_thread).tid = pthread_self();
(*s_argument_thread).thread_actif = d_vrai;
s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;	s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (pthread_setspecific(semaphore_fork_processus_courant,	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (pthread_setspecific(semaphore_fork_processus_courant,	if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
(*s_etat_processus).semaphore_fork) != 0)	pthread_self(), SEM_FORK)) == SEM_FAILED)
# endif
{
(*s_etat_processus).erreur_systeme = d_es_processus;

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

pthread_mutex_lock(&((*s_argument_thread).mutex));
pthread_mutex_unlock(&((*s_argument_thread).mutex));

(*s_argument_thread).thread_actif = d_faux;

tid_final = -2;

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

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_objets_attente[1],
&tid_final, sizeof(tid_final))) != sizeof(tid_final))
{	{
if (longueur_ecriture == -1)	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
{	return(NULL);
break;
}
}	}
	# endif

pthread_exit(NULL);	(*s_argument_thread).tid = pthread_self();
}	insertion_thread(s_etat_processus, d_faux);

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

pthread_mutex_lock(&((*s_argument_thread).mutex));	(*s_argument_thread).thread_actif = d_vrai;
pthread_mutex_unlock(&((*s_argument_thread).mutex));

(*s_argument_thread).thread_actif = d_faux;

tid_final = -2;

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

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

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

insertion_thread(s_etat_processus, d_faux);

// Envoi d'une donnée pour signaler le démarrage du thread au thread	// Envoi d'une donnée pour signaler le démarrage du thread 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;

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 171 lancement_thread(void *argument)	Line 120 lancement_thread(void *argument)

(*s_argument_thread).thread_actif = d_faux;	(*s_argument_thread).thread_actif = d_faux;

tid_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],
&tid_final, sizeof(tid_final))) != sizeof(tid_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],
&tid_final, sizeof(tid_final))) != sizeof(tid_final))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 202 lancement_thread(void *argument)	Line 139 lancement_thread(void *argument)
(*s_etat_processus).instruction_courante = NULL;	(*s_etat_processus).instruction_courante = NULL;
}	}

set = (*s_argument_thread).set;	// Attente de la réception du signal rpl_sigstart.

if (sigpending(&set) != 0)	for((*s_etat_processus).demarrage_fils = d_faux;;)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	scrutation_interruptions(s_etat_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);	if ((*s_etat_processus).demarrage_fils == d_vrai)
	{
	break;
}	}

	nanosleep(&attente, NULL);
}	}

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
Line 238 lancement_thread(void *argument)	Line 170 lancement_thread(void *argument)
fflush(stdout);	fflush(stdout);
}	}

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

sigpending(&set);

(*s_etat_processus).pid_erreur_processus_fils = getpid();	(*s_etat_processus).pid_erreur_processus_fils = getpid();

// Évaluation de l'objet	// Évaluation de l'objet

if ((*s_etat_processus).erreur_systeme == d_es)	if ((*s_etat_processus).erreur_systeme == d_es)
{	{
if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')	if (setjmp(contexte_thread) == 0)
== d_erreur)
{	{
if (((*s_etat_processus).erreur_execution == d_ex) &&	if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')
((*s_etat_processus).erreur_systeme == d_es))	== d_erreur)
{	{
(*s_etat_processus).erreur_execution =	if (((*s_etat_processus).erreur_execution == d_ex) &&
d_ex_erreur_evaluation;	((*s_etat_processus).erreur_systeme == d_es))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_evaluation;
	}
}	}
}	else
else
{
if ((*s_etat_processus).at_exit != NULL)
{	{
if (evaluation(s_etat_processus, (*s_etat_processus).at_exit,	if (((*s_etat_processus).arret_depuis_abort == 0)
'E') == d_erreur)	&& ((*s_etat_processus).at_exit != NULL))
{	{
if (((*s_etat_processus).erreur_execution == d_ex) &&	(*s_etat_processus).var_volatile_requete_arret = 0;
((*s_etat_processus).erreur_systeme == d_es))	(*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 =	if (((*s_etat_processus).erreur_execution == d_ex) &&
d_ex_erreur_evaluation;	((*s_etat_processus).erreur_systeme == d_es))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_evaluation;
	}
	}

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus, NULL);
}	}
}	}
}	}
Line 289 lancement_thread(void *argument)	Line 232 lancement_thread(void *argument)
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}

tid_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],
&tid_final, sizeof(tid_final))) != sizeof(tid_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],
&tid_final, sizeof(tid_final))) != sizeof(tid_final))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 332 lancement_thread(void *argument)	Line 265 lancement_thread(void *argument)
{	{
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 364 lancement_thread(void *argument)	Line 297 lancement_thread(void *argument)
{	{
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 406 lancement_thread(void *argument)	Line 339 lancement_thread(void *argument)

close((*s_argument_thread).pipe_erreurs[1]);	close((*s_argument_thread).pipe_erreurs[1]);
close((*s_argument_thread).pipe_interruptions[1]);	close((*s_argument_thread).pipe_interruptions[1]);
close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);	close((*s_argument_thread).pipe_nombre_elements_attente[1]);
close((*s_argument_thread).pipe_objets[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_injections[0]);
close((*s_argument_thread).pipe_nombre_injections[0]);	close((*s_argument_thread).pipe_nombre_injections[0]);
close((*s_argument_thread).pipe_acquittement[0]);	close((*s_argument_thread).pipe_acquittement[0]);
Line 448 lancement_thread(void *argument)	Line 380 lancement_thread(void *argument)
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 483 lancement_thread(void *argument)	Line 415 lancement_thread(void *argument)

if ((*s_etat_processus).var_volatile_alarme != 0)	if ((*s_etat_processus).var_volatile_alarme != 0)
{	{
kill(((((struct_processus_fils ) ((*l_element_courant)	envoi_signal_processus(((((struct_processus_fils *)
.donnee).objet)).thread).pid, SIGURG);	((l_element_courant)
	.donnee).objet)).thread).pid, rpl_sigurg);
}	}
else	else
{	{
kill(((((struct_processus_fils ) ((*l_element_courant)	if ((*s_etat_processus).arret_depuis_abort == -1)
.donnee).objet)).thread).pid, SIGFSTOP);	{
	envoi_signal_processus(((((struct_processus_fils *)
	((l_element_courant)
	.donnee).objet)).thread).pid, rpl_sigabort);
	}
	else
	{
	envoi_signal_processus(((((struct_processus_fils *)
	((l_element_courant)
	.donnee).objet)).thread).pid, rpl_sigstop);
	}
}	}
}	}
else	else
Line 523 lancement_thread(void *argument)	Line 466 lancement_thread(void *argument)
((l_element_courant).donnee).objet)).thread).mutex))	((l_element_courant).donnee).objet)).thread).mutex))
!= 0)	!= 0)
{	{
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;

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 538 lancement_thread(void *argument)	Line 482 lancement_thread(void *argument)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.thread_actif == d_vrai)	.thread_actif == d_vrai)
{	{
pthread_kill(((((struct_processus_fils *)	envoi_signal_thread(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread).tid,	((l_element_courant).donnee).objet)).thread).tid,
SIGURG);	rpl_sigurg);
}	}

if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.mutex)) != 0)	.mutex)) != 0)
{	{
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;

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 564 lancement_thread(void *argument)	Line 509 lancement_thread(void *argument)
((l_element_courant).donnee).objet)).thread).mutex))	((l_element_courant).donnee).objet)).thread).mutex))
!= 0)	!= 0)
{	{
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;

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 579 lancement_thread(void *argument)	Line 525 lancement_thread(void *argument)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.thread_actif == d_vrai)	.thread_actif == d_vrai)
{	{
pthread_kill(((((struct_processus_fils *)	if ((*s_etat_processus).arret_depuis_abort == -1)
((l_element_courant).donnee).objet)).thread).tid,	{
SIGFSTOP);	envoi_signal_thread(((((struct_processus_fils *)
	((l_element_courant).donnee).objet)).thread)
	.tid, rpl_sigabort);
	}
	else
	{
	envoi_signal_thread(((((struct_processus_fils *)
	((l_element_courant).donnee).objet)).thread)
	.tid, rpl_sigstop);
	}
}	}

if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread).mutex))	((l_element_courant).donnee).objet)).thread).mutex))
!= 0)	!= 0)
{	{
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;

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 621 lancement_thread(void *argument)	Line 577 lancement_thread(void *argument)
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;

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

registre_stop = (*s_etat_processus)	registre_stop = (*s_etat_processus)
.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).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.nombre_objets_dans_pipe; i++)	.nombre_objets_dans_pipe; i++)
{	{
Line 648 lancement_thread(void *argument)	Line 599 lancement_thread(void *argument)

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 699 lancement_thread(void *argument)	Line 651 lancement_thread(void *argument)

if (sigaction(SIGPIPE, &registre, NULL) != 0)	if (sigaction(SIGPIPE, &registre, NULL) != 0)
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex));	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);
Line 717 lancement_thread(void *argument)	Line 670 lancement_thread(void *argument)
}	}
}	}

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

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

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 859 lancement_thread(void *argument)	Line 834 lancement_thread(void *argument)
(*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(s_etat_processus,
{	(*s_etat_processus).s_arbre_variables, d_faux);
// Les définitions ne sont pas libérées parce qu'elles sont partagées
// avec le thread père.

if ((*s_etat_processus).s_liste_variables[i].niveau != 0)	l_element_statique_courant = (*s_etat_processus)
{	.l_liste_variables_statiques;
liberation(s_etat_processus,
(*s_etat_processus).s_liste_variables[i].objet);
}

free((*s_etat_processus).s_liste_variables[i].nom);
}

free((*s_etat_processus).s_liste_variables);	while(l_element_statique_courant != NULL)

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

free((*s_etat_processus).s_liste_variables_statiques);

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 1008 lancement_thread(void *argument)	Line 971 lancement_thread(void *argument)

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

for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
{	{
Line 1054 lancement_thread(void *argument)	Line 1018 lancement_thread(void *argument)
liberation_allocateur(s_etat_processus);	liberation_allocateur(s_etat_processus);

retrait_thread(s_etat_processus);	retrait_thread(s_etat_processus);
pthread_mutex_destroy(&((*s_etat_processus).mutex));	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));

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

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

pthread_mutex_lock(&((*s_argument_thread).mutex));	pthread_mutex_lock(&((*s_argument_thread).mutex));
	(*s_argument_thread).thread_actif = d_faux;
pthread_mutex_unlock(&((*s_argument_thread).mutex));	pthread_mutex_unlock(&((*s_argument_thread).mutex));

(*s_argument_thread).thread_actif = d_faux;
pthread_exit(NULL);	pthread_exit(NULL);
	return(NULL);
}	}

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.12
changed lines
	Added in v.1.83