rpl/src/instructions_m4.c - diff

Return to instructions_m4.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_m4.c between versions 1.10 and 1.55

version 1.10, 2010/06/24 10:10:44	version 1.55, 2013/03/23 16:14:39
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.17	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


#include "rpl.conv.h"	#include "rpl-conv.h"


/*	/*
Line 38	Line 38
void	void
instruction_mem(struct_processus *s_etat_processus)	instruction_mem(struct_processus *s_etat_processus)
{	{
struct_liste_chainee *l_element_courant;	integer8 j;
	integer8 nb_variables;

struct_objet *s_objet_resultat;	struct_liste_chainee *l_element_courant;

	struct_objet *s_objet_resultat;

unsigned long i;	struct_tableau_variables *tableau;

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

Line 139 instruction_mem(struct_processus *s_etat	Line 142 instruction_mem(struct_processus *s_etat
(((integer8 ) (((((((struct_liste_chainee )	(((integer8 ) (((((((struct_liste_chainee )
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;	(*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;

for(i = 0; i < (*s_etat_processus).nombre_variables; i++)	if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
{	{
(((integer8 ) (((((((struct_liste_chainee ) (*s_objet_resultat)	(*s_etat_processus).erreur_systeme = d_es_processus;
.objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) *	return;
strlen((*s_etat_processus).s_liste_variables[i].nom);
(((integer8 ) (((((((struct_liste_chainee ) (*s_objet_resultat)
.objet)).suivant)).donnee)).objet)) += occupation_memoire(
(*s_etat_processus).s_liste_variables[i].objet);
}	}

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)	nb_variables = nombre_variables(s_etat_processus);

	if ((tableau = malloc(((size_t) nb_variables) *
	sizeof(struct_tableau_variables))) == NULL)
{	{
// Comptabilisation des empreintes mémoire des variables	liberation_mutexes_arbre_variables_partagees(s_etat_processus,
// statiques qui ne sont pas accessibles, les variables statiques	((s_etat_processus).s_arbre_variables_partagees));
// accessibles étant déjà comptabilitées par la boucle précédente.	pthread_mutex_unlock(&mutex_liste_variables_partagees);
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

if ((*s_etat_processus).s_liste_variables_statiques[i].objet != NULL)	nb_variables = liste_variables(s_etat_processus, tableau);
{
(((integer8 ) (((((((struct_liste_chainee )	if (pthread_mutex_unlock(&mutex_liste_variables_partagees) != 0)
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=	{
sizeof(unsigned char) * strlen((*s_etat_processus)	(*s_etat_processus).erreur_systeme = d_es_processus;
.s_liste_variables_statiques[i].nom);	return;
(((integer8 ) (((((((struct_liste_chainee )
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
occupation_memoire((*s_etat_processus)
.s_liste_variables_statiques[i].objet);
}
}	}

for(i = 0; i < ((s_etat_processus).s_liste_variables_partagees)	for(j = 0; j < nb_variables; j++)
.nombre_variables; i++)
{	{
(((integer8 ) (((((((struct_liste_chainee )	(((integer8 ) (((((((struct_liste_chainee ) (*s_objet_resultat)
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=	.objet)).suivant)).donnee)).objet)) += (integer8)
sizeof(unsigned char) * strlen(((s_etat_processus)	(sizeof(unsigned char) * strlen(tableau[j].nom));
.s_liste_variables_partagees).table[i].nom);	(((integer8 ) (((((((struct_liste_chainee ) (*s_objet_resultat)
(((integer8 ) (((((((struct_liste_chainee )	.objet)).suivant)).donnee)).objet)) += occupation_memoire(
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=	tableau[j].objet);
occupation_memoire(((s_etat_processus)
.s_liste_variables_partagees).table[i].objet);	if(tableau[j].mutex != NULL)
	{ // La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[j].mutex);
	}
}	}

	free(tableau);

/*	/*
* Empilement du résultat	* Empilement du résultat
*/	*/
Line 397 instruction_mtxlock(struct_processus *s_	Line 401 instruction_mtxlock(struct_processus *s_
}	}

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

if (pthread_mutex_lock(&((((struct_mutex ) (*s_objet_argument).objet))	if (pthread_mutex_lock(&((((struct_mutex ) (*s_objet_argument).objet))
.mutex)) != 0)	.mutex)) != 0)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if ((*s_etat_processus).profilage == d_vrai)
{
profilage(s_etat_processus, NULL);
}

if (errno != EINTR)	if (errno != EINTR)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 442 instruction_mtxlock(struct_processus *s_	Line 437 instruction_mtxlock(struct_processus *s_
return;	return;
}	}

	(((struct_mutex ) (*s_objet_argument).objet)).tid = pthread_self();

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 597 instruction_mtxtrylock(struct_processus	Line 594 instruction_mtxtrylock(struct_processus
return;	return;
}	}
}	}
	else
	{
	(((struct_mutex ) (*s_objet_argument).objet)).tid =
	pthread_self();
	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
Line 620 instruction_mtxtrylock(struct_processus	Line 622 instruction_mtxtrylock(struct_processus
return;	return;
}	}

(((integer8 ) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;	(((integer8 ) (*s_objet_resultat).objet)) = (ios == 0) ? -1 : 0;

if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
s_objet_resultat) == d_erreur)	s_objet_resultat) == d_erreur)
Line 631 instruction_mtxtrylock(struct_processus	Line 633 instruction_mtxtrylock(struct_processus
return;	return;
}	}


/*	/*
================================================================================	================================================================================
Fonction 'mtxstatus'	Fonction 'mtxstatus'
Line 755 instruction_mtxstatus(struct_processus *	Line 758 instruction_mtxstatus(struct_processus *
}	}
}	}

if (pthread_mutex_unlock(&((((struct_mutex )	if (ios == 0)
(*s_objet_argument).objet)).mutex)) != 0)
{	{
liberation(s_etat_processus, s_objet_argument);	// Le mutex a été verrouillé par le trylock précédent.

if ((*s_etat_processus).profilage == d_vrai)	if (pthread_mutex_unlock(&((((struct_mutex )
	(*s_objet_argument).objet)).mutex)) != 0)
{	{
profilage(s_etat_processus, NULL);	liberation(s_etat_processus, s_objet_argument);
}

(*s_etat_processus).erreur_systeme = d_es_processus;	if ((*s_etat_processus).profilage == d_vrai)
return;	{
	profilage(s_etat_processus, NULL);
	}

	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
}	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 880 instruction_mtxunlock(struct_processus *	Line 888 instruction_mtxunlock(struct_processus *

if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
	liberation(s_etat_processus, s_objet_argument);

(*s_etat_processus).erreur_execution = d_ex_mutex;	(*s_etat_processus).erreur_execution = d_ex_mutex;
	return;
	}

	if (pthread_equal(pthread_self(), (((struct_mutex )
	(*s_objet_argument).objet)).tid) == 0)
	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument);

	(*s_etat_processus).erreur_execution =
	d_ex_mutex_acquis_autre_thread;
return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.10
changed lines
	Added in v.1.55