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.100 and 1.139

version 1.100, 2013/04/01 15:29:34	version 1.139, 2018/12/21 10:56:16
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.29
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2018 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 106 initialisation_allocateur(struct_process	Line 106 initialisation_allocateur(struct_process
(*s_etat_processus).pointeur_int = 0;	(*s_etat_processus).pointeur_int = 0;
(*s_etat_processus).pointeur_mat = 0;	(*s_etat_processus).pointeur_mat = 0;
(*s_etat_processus).pointeur_nom = 0;	(*s_etat_processus).pointeur_nom = 0;
	(*s_etat_processus).pointeur_rec = 0;
(*s_etat_processus).pointeur_rel = 0;	(*s_etat_processus).pointeur_rel = 0;
(*s_etat_processus).pointeur_tab = 0;	(*s_etat_processus).pointeur_tab = 0;
(*s_etat_processus).pointeur_vec = 0;	(*s_etat_processus).pointeur_vec = 0;
Line 141 liberation_allocateur(struct_processus *	Line 142 liberation_allocateur(struct_processus *
free((*s_etat_processus).objets_mat[i++]));	free((*s_etat_processus).objets_mat[i++]));
for(i = 0; i < (*s_etat_processus).pointeur_nom;	for(i = 0; i < (*s_etat_processus).pointeur_nom;
free((*s_etat_processus).objets_nom[i++]));	free((*s_etat_processus).objets_nom[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_rec;
	free((*s_etat_processus).objets_rec[i++]));
for(i = 0; i < (*s_etat_processus).pointeur_rel;	for(i = 0; i < (*s_etat_processus).pointeur_rel;
free((*s_etat_processus).objets_rel[i++]));	free((*s_etat_processus).objets_rel[i++]));
for(i = 0; i < (*s_etat_processus).pointeur_tab;	for(i = 0; i < (*s_etat_processus).pointeur_tab;
Line 343 allocation(struct_processus *s_etat_proc	Line 346 allocation(struct_processus *s_etat_proc
}	}

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

switch(type)	switch(type)
{	{
Line 434 allocation(struct_processus *s_etat_proc	Line 439 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 615 allocation(struct_processus *s_etat_proc	Line 626 allocation(struct_processus *s_etat_proc
break;	break;
}	}

	case REC :
	{
	if ((*s_etat_processus).pointeur_rec > 0)
	{
	(s_objet).objet = (s_etat_processus).objets_rec
	[--(*s_etat_processus).pointeur_rec];
	}
	else
	{
	if (((s_objet).objet = malloc(2 sizeof(struct_objet *)))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	free(s_objet);
	return(NULL);
	}
	}

	break;
	}

case REL :	case REL :
{	{
if ((*s_etat_processus).pointeur_rel > 0)	if ((*s_etat_processus).pointeur_rel > 0)
Line 821 liberation(struct_processus *s_etat_proc	Line 854 liberation(struct_processus *s_etat_proc
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

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

if (s_objet == NULL)	if (s_objet == NULL)
{	{
Line 926 liberation(struct_processus *s_etat_proc	Line 961 liberation(struct_processus *s_etat_proc
return;	return;
}	}

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

Line 1263 liberation(struct_processus *s_etat_proc	Line 1298 liberation(struct_processus *s_etat_proc
break;	break;
}	}

	case REC :
	{
	liberation(s_etat_processus,
	(((struct_record ) (*s_objet).objet)).noms);
	liberation(s_etat_processus,
	(((struct_record ) (*s_objet).objet)).donnees);

	if (decrementation_atomique(s_objet) > 0)
	{
	return;
	}

	if ((*s_etat_processus).pointeur_rec < TAILLE_CACHE)
	{
	(*s_etat_processus).objets_rec
	[(s_etat_processus).pointeur_rec++] = (s_objet).objet;
	}
	else
	{
	free((real8 ) ((s_objet).objet));
	}

	break;
	}

case REL :	case REL :
{	{
if (decrementation_atomique(s_objet) > 0)	if (decrementation_atomique(s_objet) > 0)
Line 1493 liberation(struct_processus *s_etat_proc	Line 1553 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 1591 copie_objet(struct_processus *s_etat_pro	Line 1702 copie_objet(struct_processus *s_etat_pro

integer8 i;	integer8 i;
integer8 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 2434 copie_objet(struct_processus *s_etat_pro	Line 2546 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 2800 copie_objet(struct_processus *s_etat_pro	Line 2924 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 2837 copie_etat_processus(struct_processus *s	Line 3014 copie_etat_processus(struct_processus *s

integer8 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 2863 copie_etat_processus(struct_processus *s	Line 3061 copie_etat_processus(struct_processus *s
* n'ont aucune raison de changer.	* n'ont aucune raison de changer.
*/	*/

pthread_mutexattr_init(&attributs_mutex);
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
(*s_nouvel_etat_processus).sections_critiques = 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	// Les sémaphores sont initialisés dans le nouveau thread. Il
// s'agit d'une limitation de l'implantation de l'émulation	// s'agit d'une limitation de l'implantation de l'émulation
Line 2932 copie_etat_processus(struct_processus *s	Line 3129 copie_etat_processus(struct_processus *s

// 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 2948 copie_etat_processus(struct_processus *s	Line 3145 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 2968 copie_etat_processus(struct_processus *s	Line 3166 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 2989 copie_etat_processus(struct_processus *s	Line 3188 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 3009 copie_etat_processus(struct_processus *s	Line 3209 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 3033 copie_etat_processus(struct_processus *s	Line 3235 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 3057 copie_etat_processus(struct_processus *s	Line 3261 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 3081 copie_etat_processus(struct_processus *s	Line 3286 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 3105 copie_etat_processus(struct_processus *s	Line 3311 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 3129 copie_etat_processus(struct_processus *s	Line 3336 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 3178 copie_etat_processus(struct_processus *s	Line 3386 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 3193 copie_etat_processus(struct_processus *s	Line 3403 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 3229 copie_etat_processus(struct_processus *s	Line 3440 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 3251 copie_etat_processus(struct_processus *s	Line 3463 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 3283 copie_etat_processus(struct_processus *s	Line 3496 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 3298 copie_etat_processus(struct_processus *s	Line 3513 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 3329 copie_etat_processus(struct_processus *s	Line 3545 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 3344 copie_etat_processus(struct_processus *s	Line 3562 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 3380 copie_etat_processus(struct_processus *s	Line 3599 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 3395 copie_etat_processus(struct_processus *s	Line 3616 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 3426 copie_etat_processus(struct_processus *s	Line 3648 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 3438 copie_etat_processus(struct_processus *s	Line 3662 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 3454 copie_etat_processus(struct_processus *s	Line 3678 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 3488 copie_etat_processus(struct_processus *s	Line 3714 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(((size_t) (*s_etat_processus)	rpl_malloc(s_nouvel_etat_processus, ((size_t)
.nombre_instructions_externes) *	(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 3499 copie_etat_processus(struct_processus *s	Line 3725 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 3510 copie_etat_processus(struct_processus *s	Line 3737 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 3534 copie_etat_processus(struct_processus *s	Line 3761 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);

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_allocation),	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);	&attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.100
changed lines
	Added in v.1.139