rpl/src/gestion_objets.c - diff

Return to gestion_objets.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_objets.c between versions 1.1.1.1 and 1.135

version 1.1.1.1, 2010/01/26 15:22:44	version 1.135, 2017/07/12 15:42:42
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	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"


/*	/*
================================================================================	================================================================================
Routine de gestion du nombre d'occurrences comme grandeur atomique	Routines de gestion du nombre d'occurrences comme grandeur atomique
================================================================================	================================================================================
entrées : structure sur l'état du processus et objet à afficher	entrées : structure sur l'état du processus et objet à afficher
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 57 decrementation_atomique(struct_objet *s_	Line 57 decrementation_atomique(struct_objet *s_
return((*s_objet).nombre_occurrences);	return((*s_objet).nombre_occurrences);
}	}

inline void	void
initialisation_objet(struct_objet *s_objet)	initialisation_objet(struct_objet *s_objet)
{	{
pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;
Line 111 initialisation_allocateur(struct_process	Line 111 initialisation_allocateur(struct_process
(*s_etat_processus).pointeur_vec = 0;	(*s_etat_processus).pointeur_vec = 0;
(*s_etat_processus).pointeur_maillons = 0;	(*s_etat_processus).pointeur_maillons = 0;

	(*s_etat_processus).pointeur_variables_noeud = 0;
	(*s_etat_processus).pointeur_variables_partagees_noeud = 0;
	(*s_etat_processus).pointeur_variables_feuille = 0;
	(*s_etat_processus).pointeur_variables_variable = 0;
	(*s_etat_processus).pointeur_variables_tableau_noeuds = 0;
	(*s_etat_processus).pointeur_variables_tableau_noeuds_partages = 0;

return;	return;
}	}

Line 143 liberation_allocateur(struct_processus *	Line 150 liberation_allocateur(struct_processus *
for(i = 0; i < (*s_etat_processus).pointeur_maillons;	for(i = 0; i < (*s_etat_processus).pointeur_maillons;
free((*s_etat_processus).maillons[i++]));	free((*s_etat_processus).maillons[i++]));

	for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud;
	free((*s_etat_processus).variables_noeud[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_partagees_noeud;
	free((*s_etat_processus).variables_partagees_noeud[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille;
	free((*s_etat_processus).variables_feuille[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_variable;
	free((*s_etat_processus).variables_variable[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds;
	free((*s_etat_processus).variables_tableau_noeuds[i++]));
	for(i = 0; i < (*s_etat_processus)
	.pointeur_variables_tableau_noeuds_partages;
	free((*s_etat_processus).variables_tableau_noeuds_partages[i++]));

{	{
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;
Line 224 allocation_maillon(struct_processus *s_e	Line 245 allocation_maillon(struct_processus *s_e
{	{
if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}
}	}
Line 234 allocation_maillon(struct_processus *s_e	Line 256 allocation_maillon(struct_processus *s_e

/*	/*
================================================================================	================================================================================
Routine d'allocation d'un maillon d'un objet (liste, expression...)	Routine de libération d'un maillon d'un objet (liste, expression...)
================================================================================	================================================================================
Entrées : structure sur l'état du processus et objet à afficher	Entrées : structure sur l'état du processus et objet à afficher
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 266 liberation_maillon(struct_processus *s_e	Line 288 liberation_maillon(struct_processus *s_e
================================================================================	================================================================================
Routine d'allocation d'une structure *s_objet	Routine d'allocation d'une structure *s_objet
================================================================================	================================================================================
Entrées : structure sur l'état du processus et objet à afficher	Entrées : structure sur l'état du processus et objet à allouer
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Sorties : chaine de caractères	Sorties : chaine de caractères
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 274 liberation_maillon(struct_processus *s_e	Line 296 liberation_maillon(struct_processus *s_e
================================================================================	================================================================================
*/	*/

void *	struct_objet *
allocation(struct_processus *s_etat_processus, enum t_type type)	allocation(struct_processus *s_etat_processus, enum t_type type)
{	{
struct_objet *s_objet;	struct_objet *s_objet;

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

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

// Il n'existe aucune structure struct_objet disponible dans le cache.	// Il n'existe aucune structure struct_objet disponible dans le cache.

if ((s_objet = malloc(sizeof(struct_objet))) == NULL)	if ((s_objet = malloc(sizeof(struct_objet))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

Line 299 allocation(struct_processus *s_etat_proc	Line 334 allocation(struct_processus *s_etat_proc
(*s_etat_processus).taille_pile_objets--;	(*s_etat_processus).taille_pile_objets--;

(*s_objet).nombre_occurrences = 1;	(*s_objet).nombre_occurrences = 1;

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

(*s_objet).type = type;	(*s_objet).type = type;
	(*s_objet).extension_type = 0;
	(*s_objet).descripteur_bibliotheque = NULL;

switch(type)	switch(type)
{	{
Line 314 allocation(struct_processus *s_etat_proc	Line 357 allocation(struct_processus *s_etat_proc
}	}
else	else
{	{
if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL)	if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 341 allocation(struct_processus *s_etat_proc	Line 386 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL)	if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 367 allocation(struct_processus *s_etat_proc	Line 414 allocation(struct_processus *s_etat_proc
if (((*s_objet).objet = malloc(sizeof(struct_complexe16)))	if (((*s_objet).objet = malloc(sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 379 allocation(struct_processus *s_etat_proc	Line 428 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 386 allocation(struct_processus *s_etat_proc	Line 436 allocation(struct_processus *s_etat_proc
break;	break;
}	}

	case EXT :
	{
	// Aucune allocation
	break;
	}

case FCT :	case FCT :
{	{
if ((*s_etat_processus).pointeur_fct > 0)	if ((*s_etat_processus).pointeur_fct > 0)
Line 398 allocation(struct_processus *s_etat_proc	Line 454 allocation(struct_processus *s_etat_proc
if (((*s_objet).objet = malloc(sizeof(struct_fonction)))	if (((*s_objet).objet = malloc(sizeof(struct_fonction)))
== NULL)	== NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
}	}

	(((struct_fonction ) (*s_objet).objet)).fonction = NULL;
(((struct_fonction ) (*s_objet).objet)).prediction_saut = NULL;	(((struct_fonction ) (*s_objet).objet)).prediction_saut = NULL;
	(((struct_fonction ) (*s_objet).objet)).prediction_execution
	= d_faux;
break;	break;
}	}

Line 418 allocation(struct_processus *s_etat_proc	Line 479 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)	if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 443 allocation(struct_processus *s_etat_proc	Line 506 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 466 allocation(struct_processus *s_etat_proc	Line 531 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 489 allocation(struct_processus *s_etat_proc	Line 556 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 505 allocation(struct_processus *s_etat_proc	Line 574 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}

	(((struct_mutex ) (*s_objet).objet)).tid = pthread_self();
break;	break;
}	}

Line 523 allocation(struct_processus *s_etat_proc	Line 594 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 542 allocation(struct_processus *s_etat_proc	Line 615 allocation(struct_processus *s_etat_proc
if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))	if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
== NULL)	== NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 560 allocation(struct_processus *s_etat_proc	Line 634 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)	if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 578 allocation(struct_processus *s_etat_proc	Line 654 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 590 allocation(struct_processus *s_etat_proc	Line 667 allocation(struct_processus *s_etat_proc
if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))	if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
== NULL)	== NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 601 allocation(struct_processus *s_etat_proc	Line 679 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 613 allocation(struct_processus *s_etat_proc	Line 692 allocation(struct_processus *s_etat_proc
if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))	if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
== NULL)	== NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 631 allocation(struct_processus *s_etat_proc	Line 711 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 652 allocation(struct_processus *s_etat_proc	Line 734 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 674 allocation(struct_processus *s_etat_proc	Line 758 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 696 allocation(struct_processus *s_etat_proc	Line 782 allocation(struct_processus *s_etat_proc
{	{
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)	if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
{	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
free(s_objet);	free(s_objet);
return(NULL);	return(NULL);
}	}
Line 740 liberation(struct_processus *s_etat_proc	Line 828 liberation(struct_processus *s_etat_proc
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

unsigned long i;	integer8 i;
	integer8 (__type_drop)(struct_processus ,
	void **);

if (s_objet == NULL)	if (s_objet == NULL)
{	{
Line 779 liberation(struct_processus *s_etat_proc	Line 869 liberation(struct_processus *s_etat_proc
}	}
else	else
{	{
free((unsigned long ) ((s_objet).objet));	free((*s_objet).objet);
}	}

break;	break;
Line 846 liberation(struct_processus *s_etat_proc	Line 936 liberation(struct_processus *s_etat_proc
return;	return;
}	}

free((unsigned char ) ((s_objet).objet));	free((unsigned char ) (s_objet).objet);
break;	break;
}	}

Line 874 liberation(struct_processus *s_etat_proc	Line 964 liberation(struct_processus *s_etat_proc
{	{
if (decrementation_atomique(s_objet) > 0)	if (decrementation_atomique(s_objet) > 0)
{	{
	BUG(((((struct_fichier ) (s_objet).objet)).format)
	.nombre_occurrences <= 1,
	pthread_mutex_unlock(&((*s_objet).mutex)),
	printf("((((struct_fichier ) (s_objet).objet))"
	".format).nombre_occurrences=%ld\n",
	((((struct_fichier ) (s_objet).objet)).format)
	.nombre_occurrences));

	liberation(s_etat_processus,
	(((struct_fichier ) (*s_objet).objet)).format);
return;	return;
}	}

liberation(s_etat_processus,	liberation(s_etat_processus,
(((struct_fichier ) (*s_objet).objet)).format);	(((struct_fichier ) (*s_objet).objet)).format);

free((unsigned char ) (((struct_fichier *)	free((unsigned char ) (((struct_fichier *)
(*s_objet).objet)).nom);	(*s_objet).objet)).nom);
free((struct_fichier ) ((s_objet).objet));	free((struct_fichier ) ((s_objet).objet));
Line 1059 liberation(struct_processus *s_etat_proc	Line 1158 liberation(struct_processus *s_etat_proc
return;	return;
}	}

	if (pthread_mutex_trylock(&((((struct_mutex )
	(*s_objet).objet)).mutex)) == 0)
	{
	// On a pu verrouiller le mutex. Il faut donc spécifier le tid.
	(((struct_mutex ) (*s_objet).objet)).tid = pthread_self();
	}

	if (pthread_equal(pthread_self(),
	(((struct_mutex ) (*s_objet).objet)).tid) != 0)
	{
	pthread_mutex_unlock(&((((struct_mutex )
	(*s_objet).objet)).mutex));
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_mutex_acquis_autre_thread;
	return;
	}

	pthread_mutex_destroy(&((((struct_mutex )
	(*s_objet).objet)).mutex));
free((struct_mutex ) (s_objet).objet);	free((struct_mutex ) (s_objet).objet);
break;	break;
}	}
Line 1092 liberation(struct_processus *s_etat_proc	Line 1213 liberation(struct_processus *s_etat_proc
return;	return;
}	}

free(s_objet);
break;	break;
}	}

case PRC :	case PRC :
{	{
if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1109 liberation(struct_processus *s_etat_proc	Line 1229 liberation(struct_processus *s_etat_proc
.nombre_references--;	.nombre_references--;

BUG(((((struct_processus_fils ) (s_objet).objet)).thread)	BUG(((((struct_processus_fils ) (s_objet).objet)).thread)
.nombre_references < 0, printf("((((struct_processus_fils"	.nombre_references < 0, uprintf(
	"((((struct_processus_fils"
" ) (s_objet).objet)).thread).nombre_references = %d\n",	" ) (s_objet).objet)).thread).nombre_references = %d\n",
(int) ((((struct_processus_fils ) (s_objet).objet))	(int) ((((struct_processus_fils ) (s_objet).objet))
.thread).nombre_references));	.thread).nombre_references));
Line 1125 liberation(struct_processus *s_etat_proc	Line 1246 liberation(struct_processus *s_etat_proc
}	}

if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1135 liberation(struct_processus *s_etat_proc	Line 1256 liberation(struct_processus *s_etat_proc
{	{
pthread_mutex_destroy(&(((((struct_processus_fils *)	pthread_mutex_destroy(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex));	(*s_objet).objet)).thread).mutex));
	pthread_mutex_destroy(&(((((struct_processus_fils *)
	(*s_objet).objet)).thread).mutex_nombre_references));
free((((struct_processus_fils ) (*s_objet).objet)).thread);	free((((struct_processus_fils ) (*s_objet).objet)).thread);
}	}

if (decrementation_atomique(s_objet) > 0)	if (decrementation_atomique(s_objet) > 0)
{	{
	BUG(drapeau == d_vrai, uprintf("((((struct_processus_fils"
	" ) (s_objet).objet)).thread).nombre_references "
	"= 0 with nombre_occurrences > 0\n"));
return;	return;
}	}

Line 1205 liberation(struct_processus *s_etat_proc	Line 1331 liberation(struct_processus *s_etat_proc
{	{
if (decrementation_atomique(s_objet) > 0)	if (decrementation_atomique(s_objet) > 0)
{	{
	BUG(((((struct_socket ) (s_objet).objet)).format)
	.nombre_occurrences <= 1,
	pthread_mutex_unlock(&((*s_objet).mutex)),
	printf("((((struct_socket ) (s_objet).objet))"
	".format).nombre_occurrences=%ld\n",
	((((struct_socket ) (s_objet).objet)).format)
	.nombre_occurrences));

	liberation(s_etat_processus, (((struct_socket )
	(*s_objet).objet)).format);
return;	return;
}	}

liberation(s_etat_processus, (((struct_socket )	liberation(s_etat_processus, (((struct_socket )
(*s_objet).objet)).format);	(*s_objet).objet)).format);

free((unsigned char ) (((struct_socket ) (s_objet).objet))	free((unsigned char ) (((struct_socket ) (s_objet).objet))
.adresse);	.adresse);
free((unsigned char ) (((struct_socket ) (s_objet).objet))	free((unsigned char ) (((struct_socket ) (s_objet).objet))
Line 1267 liberation(struct_processus *s_etat_proc	Line 1404 liberation(struct_processus *s_etat_proc
.nombre_occurrences <= 1,	.nombre_occurrences <= 1,
pthread_mutex_unlock(&((*s_objet).mutex)),	pthread_mutex_unlock(&((*s_objet).mutex)),
printf("(((((struct_tableau ) (s_objet).objet))"	printf("(((((struct_tableau ) (s_objet).objet))"
".element[%lu])).nombre_occurrences=%ld\n", i,	".element[%lld])).nombre_occurrences=%ld\n", i,
(((((struct_tableau ) (s_objet).objet))	(((((struct_tableau ) (s_objet).objet))
.elements[i])).nombre_occurrences));	.elements[i])).nombre_occurrences));
liberation(s_etat_processus, (((struct_tableau )	liberation(s_etat_processus, (((struct_tableau )
Line 1366 liberation(struct_processus *s_etat_proc	Line 1503 liberation(struct_processus *s_etat_proc
break;	break;
}	}

	case EXT:
	{
	if (decrementation_atomique(s_objet) > 0)
	{
	return;
	}

	// Appel de la fonction de liberation associée à l'objet
	// externe. Le descripteur de bibliothèque est directement
	// associé à la structure objet.

	l_element_courant = (*s_etat_processus).s_bibliotheques;

	while(l_element_courant != NULL)
	{
	if ((((struct_bibliotheque ) (*l_element_courant).donnee))
	.descripteur == (*s_objet).descripteur_bibliotheque)
	{
	if ((__type_drop = dlsym((*s_objet)
	.descripteur_bibliotheque, "__type_drop")) == NULL)
	{
	// La fonction de libération n'existe pas dans la
	// bibliothèque.

	(*s_etat_processus).erreur_execution =
	d_ex_type_externe_drop;
	}
	else
	{
	if (__type_drop(s_etat_processus, (void **) &s_objet)
	== 0)
	{
	(*s_etat_processus).erreur_execution =
	d_ex_type_externe_drop;
	}
	}

	break;
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	if (l_element_courant == NULL)
	{
	(*s_etat_processus).erreur_execution = d_ex_type_externe_drop;
	}

	break;
	}

default :	default :
{	{
if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
Line 1393 liberation(struct_processus *s_etat_proc	Line 1581 liberation(struct_processus *s_etat_proc
return;	return;
}	}

if (s_etat_processus != NULL)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0)
{	{
if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(s_objet).objet = (s_etat_processus).pile_objets;	}
(*s_etat_processus).pile_objets = s_objet;
(*s_etat_processus).taille_pile_objets++;
}
else
{
if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

free(s_objet);	if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
}	{
	(s_objet).objet = (s_etat_processus).pile_objets;
	(*s_etat_processus).pile_objets = s_objet;
	(*s_etat_processus).taille_pile_objets++;
}	}
else	else
{	{
	if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
	{
	pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation));
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

free(s_objet);	free(s_objet);
}	}

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

return;	return;
}	}

Line 1456 copie_objet(struct_processus *s_etat_pro	Line 1650 copie_objet(struct_processus *s_etat_pro
struct_objet *s_nouvel_objet;	struct_objet *s_nouvel_objet;
struct_objet *s_objet_tampon;	struct_objet *s_objet_tampon;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
	integer8 (__type_dup)(struct_processus , void **);

if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
{	{
Line 1508 copie_objet(struct_processus *s_etat_pro	Line 1703 copie_objet(struct_processus *s_etat_pro
return(NULL);	return(NULL);
}	}

(((unsigned long ) ((*s_nouvel_objet).objet))) =	(((integer8 ) ((*s_nouvel_objet).objet))) =
(((unsigned long ) ((*s_objet).objet)));	(((integer8 ) ((*s_objet).objet)));
break;	break;
}	}

Line 1574 copie_objet(struct_processus *s_etat_pro	Line 1769 copie_objet(struct_processus *s_etat_pro
(*l_element_courant_lecture).suivant;	(*l_element_courant_lecture).suivant;
}	}

(s_nouvel_objet).objet = (void ) ((struct_liste_chainee *)	(s_nouvel_objet).objet = ((struct_liste_chainee )
l_element_base);	l_element_base);
}	}
else // type == 'P'	else // type == 'P'
Line 1626 copie_objet(struct_processus *s_etat_pro	Line 1821 copie_objet(struct_processus *s_etat_pro
return(NULL);	return(NULL);
}	}

(s_nouvel_objet).objet = (void ) ((unsigned char *)	(s_nouvel_objet).objet = ((unsigned char )
malloc((strlen((unsigned char ) ((s_objet).objet)) + 1)	malloc((strlen((unsigned char ) ((s_objet).objet)) + 1)
* sizeof(unsigned char)));	* sizeof(unsigned char)));

Line 1720 copie_objet(struct_processus *s_etat_pro	Line 1915 copie_objet(struct_processus *s_etat_pro
(*l_element_courant_lecture).suivant;	(*l_element_courant_lecture).suivant;
}	}

(s_nouvel_objet).objet = (void ) ((struct_liste_chainee *)	(s_nouvel_objet).objet = ((struct_liste_chainee )
l_element_base);	l_element_base);
}	}
else // type == 'P'	else // type == 'P'
Line 1746 copie_objet(struct_processus *s_etat_pro	Line 1941 copie_objet(struct_processus *s_etat_pro
if (type == 'P')	if (type == 'P')
{	{
incrementation_atomique(s_objet);	incrementation_atomique(s_objet);

	if (((((struct_fichier ) ((*s_objet).objet))).format =
	copie_objet(s_etat_processus, (((struct_fichier )
	((*s_objet).objet))).format, 'P')) == NULL)
	{
	return(NULL);
	}

return(s_objet);	return(s_objet);
}	}

Line 1919 copie_objet(struct_processus *s_etat_pro	Line 2122 copie_objet(struct_processus *s_etat_pro
(*l_element_courant_lecture).suivant;	(*l_element_courant_lecture).suivant;
}	}

(s_nouvel_objet).objet = (void ) ((struct_liste_chainee *)	(s_nouvel_objet).objet = ((struct_liste_chainee )
l_element_base);	l_element_base);
}	}
else	else
Line 1954 copie_objet(struct_processus *s_etat_pro	Line 2157 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =	(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((integer8 ) malloc(	malloc(((size_t) ((((struct_matrice )
((((struct_matrice ) ((*s_objet).objet))).nombre_lignes)	((s_objet).objet))).nombre_lignes)) sizeof(integer8 *));
* sizeof(integer8 *)));

if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau
== NULL)	== NULL)
Line 1978 copie_objet(struct_processus *s_etat_pro	Line 2180 copie_objet(struct_processus *s_etat_pro
{	{
if ((((integer8 *) ((((struct_matrice *)	if ((((integer8 *) ((((struct_matrice *)
((*s_nouvel_objet).objet))).tableau))[i] =	((*s_nouvel_objet).objet))).tableau))[i] =
(void ) ((integer8 ) malloc(	((integer8 *) malloc(((size_t)
((((struct_matrice ) ((*s_objet).objet)))	((((struct_matrice ) ((*s_objet).objet)))
.nombre_colonnes) * sizeof(integer8)))) == NULL)	.nombre_colonnes)) * sizeof(integer8)))) == NULL)
{	{
for(j = 0; j < i; j++)	for(j = 0; j < i; j++)
{	{
Line 2021 copie_objet(struct_processus *s_etat_pro	Line 2223 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =	(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((struct_complexe16 ) malloc(	malloc(((size_t) ((((struct_matrice )
((((struct_matrice ) ((*s_objet).objet))).nombre_lignes)	((*s_objet).objet))).nombre_lignes))
* sizeof(struct_complexe16 *)));	* sizeof(struct_complexe16 *));

if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau
== NULL)	== NULL)
Line 2045 copie_objet(struct_processus *s_etat_pro	Line 2247 copie_objet(struct_processus *s_etat_pro
{	{
if ((((struct_complexe16 *) ((((struct_matrice *)	if ((((struct_complexe16 *) ((((struct_matrice *)
((*s_nouvel_objet).objet))).tableau))[i] =	((*s_nouvel_objet).objet))).tableau))[i] =
(void ) ((struct_complexe16 ) malloc(	((struct_complexe16 *) malloc(((size_t)
((((struct_matrice ) ((*s_objet).objet)))	((((struct_matrice ) ((*s_objet).objet)))
.nombre_colonnes) * sizeof(struct_complexe16))))	.nombre_colonnes)) * sizeof(struct_complexe16))))
== NULL)	== NULL)
{	{
for(j = 0; j < i; j++)	for(j = 0; j < i; j++)
Line 2088 copie_objet(struct_processus *s_etat_pro	Line 2290 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =	(((struct_matrice ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((real8 ) malloc(	malloc(((size_t) ((((struct_matrice )
((((struct_matrice ) ((*s_objet).objet))).nombre_lignes)	((s_objet).objet))).nombre_lignes)) sizeof(real8 *));
* sizeof(real8 *)));

if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_matrice ) ((*s_nouvel_objet).objet))).tableau
== NULL)	== NULL)
Line 2112 copie_objet(struct_processus *s_etat_pro	Line 2313 copie_objet(struct_processus *s_etat_pro
{	{
if ((((real8 *) ((((struct_matrice *)	if ((((real8 *) ((((struct_matrice *)
((*s_nouvel_objet).objet))).tableau))[i] =	((*s_nouvel_objet).objet))).tableau))[i] =
(void ) ((real8 ) malloc(	((real8 *) malloc(((size_t)
((((struct_matrice ) ((*s_objet).objet)))	((((struct_matrice ) ((*s_objet).objet)))
.nombre_colonnes) * sizeof(real8)))) == NULL)	.nombre_colonnes)) * sizeof(real8)))) == NULL)
{	{
for(j = 0; j < i; j++)	for(j = 0; j < i; j++)
{	{
Line 2142 copie_objet(struct_processus *s_etat_pro	Line 2343 copie_objet(struct_processus *s_etat_pro

case MTX :	case MTX :
{	{
if (type != 'O')	// La duplication d'un mutex renvoie le même objet.
{	incrementation_atomique(s_objet);
incrementation_atomique(s_objet);	return(s_objet);
return(s_objet);
}

if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
{
return(NULL);
}

(((struct_mutex ) ((*s_nouvel_objet).objet))).mutex =
(((struct_mutex ) ((*s_objet).objet))).mutex;
break;
}	}

case NOM :	case NOM :
Line 2197 copie_objet(struct_processus *s_etat_pro	Line 2387 copie_objet(struct_processus *s_etat_pro
return(s_objet);	return(s_objet);
}	}

	// Un objet de type NON est un objet encapsulé dans une
	// structure de type struct_objet. Elle peut très bien contenir
	// une donnée, mais c'est à l'utilisateur de la libérer
	// explicitement avec un free().

if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)	if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)
{	{
return(NULL);	return(NULL);
}	}

(*s_nouvel_objet).objet = NULL;	(s_nouvel_objet).objet = (s_objet).objet;
break;	break;
}	}

case PRC :	case PRC :
{	{
if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
return(NULL);	return(NULL);
}	}
Line 2218 copie_objet(struct_processus *s_etat_pro	Line 2413 copie_objet(struct_processus *s_etat_pro
.nombre_references++;	.nombre_references++;

if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
return(NULL);	return(NULL);
}	}
Line 2262 copie_objet(struct_processus *s_etat_pro	Line 2457 copie_objet(struct_processus *s_etat_pro
if (type == 'P')	if (type == 'P')
{	{
incrementation_atomique(s_objet);	incrementation_atomique(s_objet);

	if (((((struct_socket ) ((*s_objet).objet)))
	.format = copie_objet(s_etat_processus,
	(((struct_socket ) ((*s_objet).objet))).format, 'P'))
	== NULL)
	{
	return(NULL);
	}

return(s_objet);	return(s_objet);
}	}

Line 2292 copie_objet(struct_processus *s_etat_pro	Line 2496 copie_objet(struct_processus *s_etat_pro
(((struct_socket ) ((*s_objet).objet))).pid;	(((struct_socket ) ((*s_objet).objet))).pid;
(((struct_socket ) ((*s_nouvel_objet).objet))).tid =	(((struct_socket ) ((*s_nouvel_objet).objet))).tid =
(((struct_socket ) ((*s_objet).objet))).tid;	(((struct_socket ) ((*s_objet).objet))).tid;
	(((struct_socket ) ((*s_nouvel_objet).objet))).options =
	(((struct_socket ) ((*s_objet).objet))).options;
	(((struct_socket ) ((*s_nouvel_objet).objet))).priorite =
	(((struct_socket ) ((*s_objet).objet))).priorite;
	(((struct_socket ) ((*s_nouvel_objet).objet))).buffer_reception =
	(((struct_socket ) ((*s_objet).objet))).buffer_reception;
	(((struct_socket ) ((*s_nouvel_objet).objet))).buffer_emission =
	(((struct_socket ) ((*s_objet).objet))).buffer_emission;
	(((struct_socket ) ((*s_nouvel_objet).objet))).timeout_reception =
	(((struct_socket ) ((*s_objet).objet))).timeout_reception;
	(((struct_socket ) ((*s_nouvel_objet).objet))).timeout_emission =
	(((struct_socket ) ((*s_objet).objet))).timeout_emission;

if (((((struct_socket ) ((*s_nouvel_objet).objet))).format =	if (((((struct_socket ) ((*s_nouvel_objet).objet))).format =
copie_objet(s_etat_processus, (((struct_socket )	copie_objet(s_etat_processus, (((struct_socket )
Line 2401 copie_objet(struct_processus *s_etat_pro	Line 2617 copie_objet(struct_processus *s_etat_pro
return(NULL);	return(NULL);
}	}

	(((struct_semaphore ) (*s_nouvel_objet).objet)).semaphore =
	(((struct_semaphore ) (*s_objet).objet)).semaphore;
strcpy((((struct_semaphore ) (*s_nouvel_objet).objet)).nom,	strcpy((((struct_semaphore ) (*s_nouvel_objet).objet)).nom,
(((struct_semaphore ) (*s_objet).objet)).nom);	(((struct_semaphore ) (*s_objet).objet)).nom);
break;	break;
Line 2479 copie_objet(struct_processus *s_etat_pro	Line 2697 copie_objet(struct_processus *s_etat_pro
(*s_objet).objet)).nombre_elements;	(*s_objet).objet)).nombre_elements;

if (((((struct_tableau ) (*s_nouvel_objet).objet)).elements =	if (((((struct_tableau ) (*s_nouvel_objet).objet)).elements =
malloc((((struct_tableau ) (*s_objet).objet))	malloc(((size_t) (((struct_tableau )
.nombre_elements * sizeof(struct_objet *))) == NULL)	(*s_objet).objet)).nombre_elements)
	* sizeof(struct_objet *))) == NULL)
{	{
return(NULL);	return(NULL);
}	}
Line 2540 copie_objet(struct_processus *s_etat_pro	Line 2759 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =	(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((integer8 ) malloc(	((integer8 *) malloc(((size_t)
((((struct_vecteur ) ((*s_objet).objet))).taille)	((((struct_vecteur ) ((*s_objet).objet))).taille))
* sizeof(integer8)));	* sizeof(integer8)));

if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau
Line 2583 copie_objet(struct_processus *s_etat_pro	Line 2802 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =	(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((struct_complexe16 ) malloc(	((struct_complexe16 *) malloc(((size_t)
((((struct_vecteur ) ((*s_objet).objet))).taille)	((((struct_vecteur ) ((*s_objet).objet))).taille))
* sizeof(struct_complexe16)));	* sizeof(struct_complexe16)));

if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau
Line 2626 copie_objet(struct_processus *s_etat_pro	Line 2845 copie_objet(struct_processus *s_etat_pro
}	}

(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =	(((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau =
(void ) ((real8 ) malloc(	((real8 *) malloc(((size_t)
((((struct_vecteur ) ((*s_objet).objet))).taille)	((((struct_vecteur ) ((*s_objet).objet))).taille))
* sizeof(real8)));	* sizeof(real8)));

if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau	if ((((struct_vecteur ) ((*s_nouvel_objet).objet))).tableau
Line 2655 copie_objet(struct_processus *s_etat_pro	Line 2874 copie_objet(struct_processus *s_etat_pro
break;	break;
}	}

	case EXT:
	{
	if (type != 'O')
	{
	incrementation_atomique(s_objet);
	return(s_objet);
	}

	// Appel de la fonction de duplication associée à l'objet
	// externe. Le descripteur de bibliothèque est directement
	// associé à la structure objet.

	l_element_courant = (*s_etat_processus).s_bibliotheques;

	while(l_element_courant != NULL)
	{
	if ((((struct_bibliotheque ) (*l_element_courant).donnee))
	.descripteur == (*s_objet).descripteur_bibliotheque)
	{
	if ((__type_dup = dlsym((*s_objet).descripteur_bibliotheque,
	"__type_dup")) == NULL)
	{
	// La fonction de duplication n'existe pas dans la
	// bibliothèque.

	(*s_etat_processus).erreur_execution =
	d_ex_type_externe_dup;
	return(NULL);
	}

	s_nouvel_objet = s_objet;

	if (__type_dup(s_etat_processus, (void **) &s_nouvel_objet)
	== 0)
	{
	return(NULL);
	}

	break;
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	if (l_element_courant == NULL)
	{
	(*s_etat_processus).erreur_execution = d_ex_type_externe_dup;
	return(NULL);
	}

	break;
	}

default :	default :
{	{
return(NULL);	return(NULL);
Line 2690 copie_etat_processus(struct_processus *s	Line 2962 copie_etat_processus(struct_processus *s

struct_processus *s_nouvel_etat_processus;	struct_processus *s_nouvel_etat_processus;

unsigned long i;	integer8 i;

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(NULL);	return(NULL);
}	}

if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)	if ((s_nouvel_etat_processus = sys_malloc(sizeof(struct_processus)))
	== NULL)
{	{
	if (pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(NULL);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

(s_nouvel_etat_processus) = (s_etat_processus);	(s_nouvel_etat_processus) = (s_etat_processus);

// On réinitialise l'allocateur.	// On réinitialise les allocateurs.

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation_buffer),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

initialisation_allocateur(s_nouvel_etat_processus);	initialisation_allocateur(s_nouvel_etat_processus);
	initialisation_allocateur_buffer(s_nouvel_etat_processus);

/*	/*
* (*s_etat_processus).definition_chainee,	* (*s_etat_processus).definition_chainee,
Line 2718 copie_etat_processus(struct_processus *s	Line 3011 copie_etat_processus(struct_processus *s
* n'ont aucune raison de changer.	* n'ont aucune raison de changer.
*/	*/

sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);	(*s_nouvel_etat_processus).sections_critiques = 0;
	(*s_nouvel_etat_processus).initialisation_scheduler = d_faux;

	// Les sémaphores sont initialisés dans le nouveau thread. Il
	// s'agit d'une limitation de l'implantation de l'émulation
	// de sem_init().

	initialisation_contexte_cas(s_etat_processus);

(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;	(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
	(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
(*s_nouvel_etat_processus).fichiers_graphiques = NULL;	(*s_nouvel_etat_processus).fichiers_graphiques = NULL;
(*s_nouvel_etat_processus).entree_standard = NULL;	(*s_nouvel_etat_processus).entree_standard = NULL;
(*s_nouvel_etat_processus).s_marques = NULL;	(*s_nouvel_etat_processus).s_marques = NULL;
Line 2730 copie_etat_processus(struct_processus *s	Line 3031 copie_etat_processus(struct_processus *s
(*s_nouvel_etat_processus).expression_courante = NULL;	(*s_nouvel_etat_processus).expression_courante = NULL;
(*s_nouvel_etat_processus).objet_courant = NULL;	(*s_nouvel_etat_processus).objet_courant = NULL;
(*s_nouvel_etat_processus).processus_detache = d_faux;	(*s_nouvel_etat_processus).processus_detache = d_faux;
	(*s_nouvel_etat_processus).evaluation_forcee = 'N';

(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;	(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
(*s_nouvel_etat_processus).nombre_objets_injectes = 0;	(*s_nouvel_etat_processus).nombre_objets_injectes = 0;
Line 2749 copie_etat_processus(struct_processus *s	Line 3051 copie_etat_processus(struct_processus *s
(*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;	(*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;	(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;

	(*s_nouvel_etat_processus).at_exit = NULL;
	(*s_nouvel_etat_processus).at_poke = NULL;
	(*s_nouvel_etat_processus).traitement_at_poke = 'N';

for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
{	{
(*s_nouvel_etat_processus).corps_interruptions[i] = NULL;	(*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
Line 2759 copie_etat_processus(struct_processus *s	Line 3065 copie_etat_processus(struct_processus *s

if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)	if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
{	{
(*s_nouvel_etat_processus).generateur_aleatoire = NULL;	if (((*s_nouvel_etat_processus).generateur_aleatoire =
}	gsl_rng_clone((*s_etat_processus).generateur_aleatoire))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

(*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;	gsl_rng_set((*s_nouvel_etat_processus).generateur_aleatoire,
	gsl_rng_get((*s_etat_processus).generateur_aleatoire));
	}

// Copie de la localisation	// Copie de la localisation

if (((*s_nouvel_etat_processus).localisation = malloc((strlen(	if (((*s_nouvel_etat_processus).localisation = rpl_malloc(
(s_etat_processus).localisation) + 1) sizeof(unsigned char)))	s_nouvel_etat_processus, (strlen((*s_etat_processus).localisation)
== NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2782 copie_etat_processus(struct_processus *s	Line 3095 copie_etat_processus(struct_processus *s
if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,	if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
(*s_etat_processus).indep, 'P')) == NULL)	(*s_etat_processus).indep, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2802 copie_etat_processus(struct_processus *s	Line 3116 copie_etat_processus(struct_processus *s
if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,	if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
(*s_etat_processus).depend, 'P')) == NULL)	(*s_etat_processus).depend, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2823 copie_etat_processus(struct_processus *s	Line 3138 copie_etat_processus(struct_processus *s
copie_objet(s_etat_processus, (*s_etat_processus)	copie_objet(s_etat_processus, (*s_etat_processus)
.parametres_courbes_de_niveau, 'P')) == NULL)	.parametres_courbes_de_niveau, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2843 copie_etat_processus(struct_processus *s	Line 3159 copie_etat_processus(struct_processus *s
if (((*s_etat_processus).instruction_courante != NULL) &&	if (((*s_etat_processus).instruction_courante != NULL) &&
(*s_etat_processus).evaluation_expression_compilee == 'N')	(*s_etat_processus).evaluation_expression_compilee == 'N')
{	{
if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(	if (((*s_nouvel_etat_processus).instruction_courante = rpl_malloc(
	s_nouvel_etat_processus, (strlen(
(s_etat_processus).instruction_courante) + 1)	(s_etat_processus).instruction_courante) + 1)
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2867 copie_etat_processus(struct_processus *s	Line 3185 copie_etat_processus(struct_processus *s

if ((*s_etat_processus).label_x != NULL)	if ((*s_etat_processus).label_x != NULL)
{	{
if (((*s_nouvel_etat_processus).label_x = malloc((strlen(	if (((*s_nouvel_etat_processus).label_x = rpl_malloc(
	s_nouvel_etat_processus, (strlen(
(s_etat_processus).label_x) + 1)	(s_etat_processus).label_x) + 1)
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2891 copie_etat_processus(struct_processus *s	Line 3211 copie_etat_processus(struct_processus *s

if ((*s_etat_processus).label_y != NULL)	if ((*s_etat_processus).label_y != NULL)
{	{
if (((*s_nouvel_etat_processus).label_y = malloc((strlen(	if (((*s_nouvel_etat_processus).label_y = rpl_malloc(
(s_etat_processus).label_y) + 1)	s_nouvel_etat_processus, (strlen((*s_etat_processus).label_y)
sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2915 copie_etat_processus(struct_processus *s	Line 3236 copie_etat_processus(struct_processus *s

if ((*s_etat_processus).label_z != NULL)	if ((*s_etat_processus).label_z != NULL)
{	{
if (((*s_nouvel_etat_processus).label_z = malloc((strlen(	if (((*s_nouvel_etat_processus).label_z = rpl_malloc(
(s_etat_processus).label_z) + 1)	s_nouvel_etat_processus, (strlen((*s_etat_processus).label_z)
sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2939 copie_etat_processus(struct_processus *s	Line 3261 copie_etat_processus(struct_processus *s

if ((*s_etat_processus).titre != NULL)	if ((*s_etat_processus).titre != NULL)
{	{
if (((*s_nouvel_etat_processus).titre = malloc((strlen(	if (((*s_nouvel_etat_processus).titre = rpl_malloc(
(s_etat_processus).titre) + 1)	s_nouvel_etat_processus, (strlen((*s_etat_processus).titre) + 1)
sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2963 copie_etat_processus(struct_processus *s	Line 3286 copie_etat_processus(struct_processus *s

if ((*s_etat_processus).legende != NULL)	if ((*s_etat_processus).legende != NULL)
{	{
if (((*s_nouvel_etat_processus).legende = malloc((strlen(	if (((*s_nouvel_etat_processus).legende = rpl_malloc(
(s_etat_processus).legende) + 1)	s_nouvel_etat_processus, (strlen((*s_etat_processus).legende)
sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 2989 copie_etat_processus(struct_processus *s	Line 3313 copie_etat_processus(struct_processus *s
* Copie de la table des variables	* Copie de la table des variables
*/	*/

if (((*s_nouvel_etat_processus).s_liste_variables =	(*s_nouvel_etat_processus).l_liste_variables_statiques = NULL;
malloc((s_etat_processus).nombre_variables_allouees	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
sizeof(struct_variable))) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
{
if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
+ 1) * sizeof(unsigned char))) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
(*s_etat_processus).s_liste_variables[i].nom);

(*s_nouvel_etat_processus).s_liste_variables[i].origine =
(*s_etat_processus).s_liste_variables[i].origine;
(*s_nouvel_etat_processus).s_liste_variables[i].niveau =
(*s_etat_processus).s_liste_variables[i].niveau;
(*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
(*s_etat_processus).s_liste_variables[i].variable_statique;
(*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
(*s_etat_processus).s_liste_variables[i].variable_verrouillee;

// Les définitions sont partagées entre tous les threads.	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)

if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
{
(*s_nouvel_etat_processus).s_liste_variables[i].objet =
(*s_etat_processus).s_liste_variables[i].objet;
}
else
{
if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
copie_objet(s_etat_processus,
(*s_etat_processus).s_liste_variables[i]
.objet, 'P')) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}
}
}

/*
* Copie de la table des variables statiques
*/

if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
malloc((s_etat_processus).nombre_variables_statiques_allouees
sizeof(struct_variable_statique))) == NULL)
{	{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)	((s_nouvel_etat_processus).l_liste_variables_partagees) =
{	((s_etat_processus).l_liste_variables_partagees);
if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =	((s_nouvel_etat_processus).s_arbre_variables_partagees) =
malloc((strlen((*s_etat_processus).s_liste_variables_statiques	((s_etat_processus).s_arbre_variables_partagees);
[i].nom) + 1) * sizeof(unsigned char))) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
(*s_etat_processus).s_liste_variables_statiques[i].nom);

(*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
(*s_etat_processus).s_liste_variables_statiques[i].origine;
(*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
(*s_etat_processus).s_liste_variables_statiques[i].niveau;
(*s_nouvel_etat_processus).s_liste_variables_statiques[i]
.variable_statique = (*s_etat_processus)
.s_liste_variables_statiques[i].variable_statique;

if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
copie_objet(s_etat_processus, (*s_etat_processus)
.s_liste_variables_statiques[i].objet, 'P')) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}
}

/*	/*
* Copie de la pile opérationnelle	* Copie de la pile opérationnelle
Line 3127 copie_etat_processus(struct_processus *s	Line 3336 copie_etat_processus(struct_processus *s

while(l_element_lecture != NULL)	while(l_element_lecture != NULL)
{	{
if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
	sizeof(struct_liste_chainee))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3142 copie_etat_processus(struct_processus *s	Line 3353 copie_etat_processus(struct_processus *s
if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,	if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
(*l_element_lecture).donnee, 'P')) == NULL)	(*l_element_lecture).donnee, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3178 copie_etat_processus(struct_processus *s	Line 3390 copie_etat_processus(struct_processus *s

if ((*s_nouvel_etat_processus).erreur_systeme != d_es)	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
{	{
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(NULL);	return(NULL);
Line 3200 copie_etat_processus(struct_processus *s	Line 3413 copie_etat_processus(struct_processus *s

if ((*s_nouvel_etat_processus).erreur_systeme != d_es)	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
{	{
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(NULL);	return(NULL);
Line 3224 copie_etat_processus(struct_processus *s	Line 3438 copie_etat_processus(struct_processus *s
* Copie des différents contextes	* Copie des différents contextes
*/	*/

	(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
	(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;

(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;	(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
l_element_lecture = (*s_etat_processus).l_base_pile_contextes;	l_element_lecture = (*s_etat_processus).l_base_pile_contextes;

while(l_element_lecture != NULL)	while(l_element_lecture != NULL)
{	{
if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
	sizeof(struct_liste_chainee))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3244 copie_etat_processus(struct_processus *s	Line 3463 copie_etat_processus(struct_processus *s
if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,	if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
(*l_element_lecture).donnee, 'P')) == NULL)	(*l_element_lecture).donnee, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3275 copie_etat_processus(struct_processus *s	Line 3495 copie_etat_processus(struct_processus *s

while(l_element_lecture != NULL)	while(l_element_lecture != NULL)
{	{
if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
	sizeof(struct_liste_chainee))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3290 copie_etat_processus(struct_processus *s	Line 3512 copie_etat_processus(struct_processus *s
if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,	if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
(*l_element_lecture).donnee, 'P')) == NULL)	(*l_element_lecture).donnee, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3326 copie_etat_processus(struct_processus *s	Line 3549 copie_etat_processus(struct_processus *s

while(l_element_lecture != NULL)	while(l_element_lecture != NULL)
{	{
if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
	sizeof(struct_liste_chainee))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3341 copie_etat_processus(struct_processus *s	Line 3566 copie_etat_processus(struct_processus *s
if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,	if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
(*l_element_lecture).donnee, 'P')) == NULL)	(*l_element_lecture).donnee, 'P')) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3372 copie_etat_processus(struct_processus *s	Line 3598 copie_etat_processus(struct_processus *s

while(l_element_lecture != NULL)	while(l_element_lecture != NULL)
{	{
if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
	sizeof(struct_liste_chainee))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3384 copie_etat_processus(struct_processus *s	Line 3612 copie_etat_processus(struct_processus *s
return(NULL);	return(NULL);
}	}

if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))	if (((*l_element_suivant).donnee = rpl_malloc(s_nouvel_etat_processus,
== NULL)	sizeof(struct_bibliotheque))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3400 copie_etat_processus(struct_processus *s	Line 3628 copie_etat_processus(struct_processus *s
= (((struct_bibliotheque ) (*l_element_lecture).donnee)).tid;	= (((struct_bibliotheque ) (*l_element_lecture).donnee)).tid;

if (((((struct_bibliotheque ) (*l_element_suivant).donnee)).nom =	if (((((struct_bibliotheque ) (*l_element_suivant).donnee)).nom =
malloc((strlen((((struct_bibliotheque ) (*l_element_lecture)	rpl_malloc(s_nouvel_etat_processus,
	(strlen((((struct_bibliotheque ) (*l_element_lecture)
.donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)	.donnee)).nom) + 1) * sizeof(unsigned char))) == 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_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3434 copie_etat_processus(struct_processus *s	Line 3664 copie_etat_processus(struct_processus *s
if ((*s_etat_processus).nombre_instructions_externes != 0)	if ((*s_etat_processus).nombre_instructions_externes != 0)
{	{
if (((*s_nouvel_etat_processus).s_instructions_externes =	if (((*s_nouvel_etat_processus).s_instructions_externes =
malloc((s_etat_processus).nombre_instructions_externes	rpl_malloc(s_nouvel_etat_processus, ((size_t)
	(s_etat_processus).nombre_instructions_externes)
sizeof(struct_instruction_externe))) == NULL)	sizeof(struct_instruction_externe))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 3444 copie_etat_processus(struct_processus *s	Line 3675 copie_etat_processus(struct_processus *s
for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)	for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
{	{
if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =	if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
malloc((strlen((*s_etat_processus).s_instructions_externes	rpl_malloc(s_nouvel_etat_processus,
	(strlen((*s_etat_processus).s_instructions_externes
[i].nom) + 1) * sizeof(unsigned char))) == NULL)	[i].nom) + 1) * sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 3455 copie_etat_processus(struct_processus *s	Line 3687 copie_etat_processus(struct_processus *s
(*s_etat_processus).s_instructions_externes[i].nom);	(*s_etat_processus).s_instructions_externes[i].nom);

if (((*s_nouvel_etat_processus).s_instructions_externes[i]	if (((*s_nouvel_etat_processus).s_instructions_externes[i]
.nom_bibliotheque = malloc((strlen((*s_etat_processus)	.nom_bibliotheque = rpl_malloc(s_nouvel_etat_processus,
.s_instructions_externes[i].nom_bibliotheque) + 1) *	(strlen((*s_etat_processus).s_instructions_externes[i]
sizeof(unsigned char))) == NULL)	.nom_bibliotheque) + 1) * sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 3479 copie_etat_processus(struct_processus *s	Line 3711 copie_etat_processus(struct_processus *s

pthread_mutexattr_init(&attributs_mutex);	pthread_mutexattr_init(&attributs_mutex);
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_pile_processus),
	&attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_interruptions),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_signaux),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_nouvel_etat_processus).protection_liste_mutexes),
	&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;
return(NULL);	return(NULL);
Line 3493 copie_etat_processus(struct_processus *s	Line 3744 copie_etat_processus(struct_processus *s
#undef return	#undef return
}	}


	/*
	================================================================================
	Routines de debug
	================================================================================
	entrées :
	--------------------------------------------------------------------------------
	sorties :
	--------------------------------------------------------------------------------
	effets de bord : néant
	================================================================================
	*/

	#ifdef DEBUG_MEMOIRE

	#undef malloc
	#undef realloc
	#undef free
	#undef fork

	#ifdef return
	# undef return
	#endif

	#ifdef __BACKTRACE
	#define PROFONDEUR_PILE 64
	#define return(a) { if (a == NULL) \
	{ BACKTRACE(PROFONDEUR_PILE); \
	fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
	return(a); } while(0)
	#endif

	#undef fprintf
	#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
	#undef CORE_DUMP

	typedef struct memoire
	{
	void *pointeur;
	unsigned char *fonction;
	unsigned char *argument;
	unsigned long ligne;
	size_t taille;
	unsigned long long ordre;
	# ifdef __BACKTRACE
	void *pile[PROFONDEUR_PILE];
	int profondeur;
	# endif
	struct memoire *suivant;
	} struct_memoire;

	static struct_memoire *debug = NULL;
	static unsigned long long ordre = 0;
	static pthread_mutex_t mutex_allocation;

	void
	debug_memoire_initialisation()
	{
	pthread_mutexattr_t attributs_mutex;

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

	return;
	}

	void *
	debug_memoire_ajout(size_t taille, const unsigned char *fonction,
	unsigned long ligne, const unsigned char *argument)
	{
	struct_memoire *ancienne_base;

	void *pointeur;

	pthread_mutex_lock(&mutex_allocation);

	ancienne_base = debug;

	if ((debug = malloc(sizeof(struct_memoire))) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	if (((*debug).pointeur = malloc(taille)) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	(*debug).suivant = ancienne_base;
	(*debug).ligne = ligne;
	(*debug).taille = taille;
	(*debug).ordre = ordre;

	pointeur = (*debug).pointeur;

	# ifdef __BACKTRACE
	(debug).profondeur = backtrace((debug).pile, PROFONDEUR_PILE);
	# endif

	if (((debug).fonction = malloc((strlen(fonction) + 1)
	sizeof(unsigned char))) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	if (((debug).argument = malloc((strlen(argument) + 1)
	sizeof(unsigned char))) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	strcpy((*debug).fonction, fonction);
	strcpy((*debug).argument, argument);

	memset((debug).pointeur, 0, (debug).taille);

	pthread_mutex_unlock(&mutex_allocation);
	ordre++;

	return(pointeur);
	}

	void *
	debug_memoire_modification(void *pointeur, size_t taille,
	const unsigned char *fonction, unsigned long ligne,
	const unsigned char *argument)
	{
	struct_memoire *element_courant;

	if (pointeur != NULL)
	{
	if (taille == 0)
	{
	// Revient à free(). Il n'y a pas de parenthèses car on ne veut
	// pas utiliser la macro return().

	debug_memoire_retrait(pointeur);
	return NULL ;
	}
	else
	{
	// Réallocation réelle

	pthread_mutex_lock(&mutex_allocation);

	element_courant = debug;

	while(element_courant != NULL)
	{
	if ((*element_courant).pointeur == pointeur)
	{
	break;
	}

	element_courant = (*element_courant).suivant;
	}

	if (element_courant == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);

	uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
	getpid(), (unsigned long long) pthread_self());
	# ifdef __BACKTRACE
	BACKTRACE(PROFONDEUR_PILE);
	# endif

	return(realloc(pointeur, taille));
	}
	else
	{
	if (((*element_courant).pointeur = realloc(pointeur, taille))
	== NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	(*element_courant).ligne = ligne;
	(*element_courant).taille = taille;
	free((*element_courant).fonction);
	free((*element_courant).argument);

	if (((*element_courant).fonction = malloc((strlen(fonction)
	+ 1) * sizeof(unsigned char))) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	if (((*element_courant).argument = malloc((strlen(argument)
	+ 1) * sizeof(unsigned char))) == NULL)
	{
	pthread_mutex_unlock(&mutex_allocation);
	return(NULL);
	}

	strcpy((*element_courant).fonction, fonction);
	strcpy((*element_courant).argument, argument);

	pthread_mutex_unlock(&mutex_allocation);

	return((*element_courant).pointeur);
	}
	}
	}
	else
	{
	// Revient à malloc()
	pointeur = debug_memoire_ajout(taille, fonction, ligne, argument);
	return(pointeur);
	}
	}

	void
	debug_memoire_retrait(void *pointeur)
	{
	struct_memoire *element_courant;
	struct_memoire *element_precedent;

	pthread_mutex_lock(&mutex_allocation);

	element_courant = debug;
	element_precedent = NULL;

	while(element_courant != NULL)
	{
	if ((*element_courant).pointeur == pointeur)
	{
	if (element_precedent == NULL)
	{
	debug = (*debug).suivant;
	}
	else
	{
	(element_precedent).suivant = (element_courant).suivant;
	}

	if (pointeur != NULL)
	{
	memset(pointeur, 0, (*element_courant).taille);
	}

	free((*element_courant).fonction);
	free((*element_courant).argument);
	free(element_courant);

	break;
	}

	element_precedent = element_courant;
	element_courant = (*element_courant).suivant;
	}

	pthread_mutex_unlock(&mutex_allocation);

	if (element_courant == NULL)
	{
	uprintf("[%d-%llu] ILLEGAL POINTER (free)\n",
	getpid(), (unsigned long long) pthread_self());
	# ifdef __BACKTRACE
	BACKTRACE(PROFONDEUR_PILE);
	# endif
	}

	free(pointeur);
	return;
	}

	void
	debug_memoire_verification()
	{
	# ifdef __BACKTRACE
	char **appels;

	int j;
	# endif

	integer8 i;

	struct_memoire *element_courant;
	struct_memoire *element_suivant;

	fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n",
	getpid(), (unsigned long long) pthread_self());

	pthread_mutex_lock(&mutex_allocation);

	element_courant = debug;
	i = 1;

	while(element_courant != NULL)
	{
	fprintf(stderr, "[%d-%llu] MEDITATION %lld (%llu)\n", getpid(),
	(unsigned long long) pthread_self(), i,
	(*element_courant).ordre);
	fprintf(stderr, "[%d-%llu] P: %p, F: %s(), L: %lu, S: %d\n",
	getpid(), (unsigned long long) pthread_self(),
	(*element_courant).pointeur,
	(element_courant).fonction, (element_courant).ligne,
	(int) (*element_courant).taille);
	fprintf(stderr, "[%d-%llu] A: %s\n", getpid(),
	(unsigned long long) pthread_self(),
	(*element_courant).argument);

	if (strstr((*element_courant).argument, "sizeof(unsigned char)")
	!= NULL)
	{
	fprintf(stderr, "[%d-%llu] ", getpid(),
	(unsigned long long) pthread_self());
	fprintf(stderr, "O: %s\n", (unsigned char *)
	(*element_courant).pointeur);
	}
	else if (strcmp((*element_courant).argument, "sizeof(struct_objet)")
	== 0)
	{
	fprintf(stderr, "[%d-%llu] ", getpid(),
	(unsigned long long) pthread_self());
	fprintf(stderr, "O: %d\n", (((struct_objet )
	(*element_courant).pointeur)).type);
	}
	else if (strcmp((*element_courant).argument,
	"sizeof(struct_liste_chainee)") == 0)
	{
	fprintf(stderr, "[%d-%llu] ", getpid(),
	(unsigned long long) pthread_self());
	fprintf(stderr, "O: data=%p next=%p\n", (((struct_liste_chainee )
	(*element_courant).pointeur)).donnee,
	(((struct_liste_chainee ) (*element_courant).pointeur))
	.suivant);
	}

	# ifdef __BACKTRACE
	appels = backtrace_symbols((*element_courant).pile,
	(*element_courant).profondeur);

	fprintf(stderr, "[%d-%llu] BACKTRACE\n",
	getpid(), (unsigned long long) pthread_self());

	if (appels != NULL)
	{
	for(j = 0; j < (*element_courant).profondeur; j++)
	{
	fprintf(stderr, "[%d-%llu] %s\n", getpid(),
	(unsigned long long) pthread_self(), appels[j]);
	}

	free(appels);
	}
	# endif

	fprintf(stderr, "\n");

	i++;

	element_suivant = (*element_courant).suivant;

	# ifndef CORE_DUMP
	free((*element_courant).fonction);
	free((*element_courant).argument);
	free(element_courant);
	# endif

	element_courant = element_suivant;
	}

	pthread_mutex_unlock(&mutex_allocation);
	pthread_mutex_destroy(&mutex_allocation);

	fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
	(unsigned long long) pthread_self());

	return;
	}

	pid_t
	debug_fork()
	{
	pid_t pid;

	pthread_mutex_lock(&mutex_allocation);
	pid = fork();

	if (pid == 0)
	{
	liberation_queue_signaux(s_etat_processus);
	creation_queue_signaux(s_etat_processus);

	pthread_mutex_destroy(&mutex_allocation);
	debug_memoire_initialisation();
	}
	else
	{
	pthread_mutex_unlock(&mutex_allocation);
	}

	// Pas de parenthèses pour ne pas remplacer return par sa macro.
	return pid;
	}

	void
	analyse_post_mortem()
	{
	# ifdef CORE_DUMP
	BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR "
	"POST MORTEM ANALYZE\n", getpid(),
	(unsigned long long) pthread_self()));
	# endif

	return;
	}

	#endif

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1.1.1
changed lines
	Added in v.1.135