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.96 and 1.123

version 1.96, 2013/03/10 17:01:05	version 1.123, 2015/09/18 13:41:10
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.23
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2015 Dr. BERTRAND Joël

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

Line 355 allocation(struct_processus *s_etat_proc	Line 355 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 =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 820 liberation(struct_processus *s_etat_proc	Line 820 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;

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

break;	break;
Line 926 liberation(struct_processus *s_etat_proc	Line 926 liberation(struct_processus *s_etat_proc
return;	return;
}	}

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

Line 1394 liberation(struct_processus *s_etat_proc	Line 1394 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 1589 copie_objet(struct_processus *s_etat_pro	Line 1589 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;

if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
{	{
Line 1641 copie_objet(struct_processus *s_etat_pro	Line 1641 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 1707 copie_objet(struct_processus *s_etat_pro	Line 1707 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 1759 copie_objet(struct_processus *s_etat_pro	Line 1759 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 1853 copie_objet(struct_processus *s_etat_pro	Line 1853 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 2060 copie_objet(struct_processus *s_etat_pro	Line 2060 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 2095 copie_objet(struct_processus *s_etat_pro	Line 2095 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 2119 copie_objet(struct_processus *s_etat_pro	Line 2118 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 2162 copie_objet(struct_processus *s_etat_pro	Line 2161 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 2186 copie_objet(struct_processus *s_etat_pro	Line 2185 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 2229 copie_objet(struct_processus *s_etat_pro	Line 2228 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 2253 copie_objet(struct_processus *s_etat_pro	Line 2251 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 2436 copie_objet(struct_processus *s_etat_pro	Line 2434 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 2625 copie_objet(struct_processus *s_etat_pro	Line 2635 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 2686 copie_objet(struct_processus *s_etat_pro	Line 2697 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 2729 copie_objet(struct_processus *s_etat_pro	Line 2740 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 2772 copie_objet(struct_processus *s_etat_pro	Line 2783 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 2836 copie_etat_processus(struct_processus *s	Line 2847 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)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2852 copie_etat_processus(struct_processus *s	Line 2864 copie_etat_processus(struct_processus *s

(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 2864 copie_etat_processus(struct_processus *s	Line 2889 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 2933 copie_etat_processus(struct_processus *s	Line 2957 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 2949 copie_etat_processus(struct_processus *s	Line 2973 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 2969 copie_etat_processus(struct_processus *s	Line 2994 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 2990 copie_etat_processus(struct_processus *s	Line 3016 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 3010 copie_etat_processus(struct_processus *s	Line 3037 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 3034 copie_etat_processus(struct_processus *s	Line 3063 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 3058 copie_etat_processus(struct_processus *s	Line 3089 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 3082 copie_etat_processus(struct_processus *s	Line 3114 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 3106 copie_etat_processus(struct_processus *s	Line 3139 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 3130 copie_etat_processus(struct_processus *s	Line 3164 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 3179 copie_etat_processus(struct_processus *s	Line 3214 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 3194 copie_etat_processus(struct_processus *s	Line 3231 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 3230 copie_etat_processus(struct_processus *s	Line 3268 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 3252 copie_etat_processus(struct_processus *s	Line 3291 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 3284 copie_etat_processus(struct_processus *s	Line 3324 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 3299 copie_etat_processus(struct_processus *s	Line 3341 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 3330 copie_etat_processus(struct_processus *s	Line 3373 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 3345 copie_etat_processus(struct_processus *s	Line 3390 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 3381 copie_etat_processus(struct_processus *s	Line 3427 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 3396 copie_etat_processus(struct_processus *s	Line 3444 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 3427 copie_etat_processus(struct_processus *s	Line 3476 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 3439 copie_etat_processus(struct_processus *s	Line 3490 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 3455 copie_etat_processus(struct_processus *s	Line 3506 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 3489 copie_etat_processus(struct_processus *s	Line 3542 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 3499 copie_etat_processus(struct_processus *s	Line 3553 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 3565 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 3589 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);	&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.96
changed lines
	Added in v.1.123