rpl/src/instructions_v1.c - diff

Return to instructions_v1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_v1.c between versions 1.19 and 1.85

version 1.19, 2011/06/10 11:35:13	version 1.85, 2025/04/15 10:17:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.0	RPL/2 (R) version 4.1.36
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2025 Dr. BERTRAND Joël

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

Line 42 instruction_var(struct_processus *s_etat	Line 42 instruction_var(struct_processus *s_etat
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;
struct_objet *s_objet_temporaire;	struct_objet *s_objet_temporaire;

unsigned long nombre_colonnes;	integer8 nombre_colonnes;

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

Line 132 instruction_var(struct_processus *s_etat	Line 132 instruction_var(struct_processus *s_etat
return;	return;
}	}

if (((s_objet_resultat).objet = variance_statistique((struct_matrice )	if (((*s_objet_resultat).objet = variance_statistique(s_etat_processus,
(*s_objet_statistique).objet, 'E')) == NULL)	(struct_matrice ) (s_objet_statistique).objet, 'E')) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 237 instruction_version(struct_processus *s_	Line 237 instruction_version(struct_processus *s_
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned char texte[] = "RPL/2 version ";	unsigned char texte[] = "RPL/2 version ";
	unsigned char tampon[256 + 1];

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

Line 499 instruction_version(struct_processus *s_	Line 500 instruction_version(struct_processus *s_
return;	return;
}	}

if ((((l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)	if ((((l_element_courant).donnee).objet =
+ 1) * sizeof(unsigned char))) == NULL)	date_compilation(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
d_date_en_rpl);

/*	/*
* Ajout des options de compilation	* Ajout des options de compilation
*/	*/
Line 830 instruction_version(struct_processus *s_	Line 828 instruction_version(struct_processus *s_
return;	return;
}	}

#ifdef DEBUG	#ifdef RPLCAS
if ((((l_element_courant).donnee).objet = malloc(6 *	if ((((l_element_courant).donnee).objet = malloc(8 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 839 instruction_version(struct_processus *s_	Line 837 instruction_version(struct_processus *s_
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,	strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
"DEBUG");	"RPL/CAS");
#else	#else
if ((((l_element_courant).donnee).objet = malloc(15 *	if ((((l_element_courant).donnee).objet = malloc(17 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 849 instruction_version(struct_processus *s_	Line 847 instruction_version(struct_processus *s_
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,	strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
"DEBUG DISABLED");	"RPL/CAS DISABLED");
#endif	#endif

if (((*l_element_courant).suivant =	if (((*l_element_courant).suivant =
Line 891 instruction_version(struct_processus *s_	Line 889 instruction_version(struct_processus *s_
"EXPERIMENTAL CODE DISABLED");	"EXPERIMENTAL CODE DISABLED");
#endif	#endif

	if (((*l_element_courant).suivant =
	allocation_maillon(s_etat_processus)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	sprintf(tampon, "%zu BITS ABI", sizeof(void ) 8);

	if ((((l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	strcpy((unsigned char ) ((*l_element_courant).donnee).objet, tampon);

	if (((*l_element_courant).suivant =
	allocation_maillon(s_etat_processus)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	if ((((l_element_courant).donnee).objet = conversion_majuscule(
	s_etat_processus, HOST)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

/*	/*
* Empilement du résultat	* Empilement du résultat
*/	*/
Line 920 instruction_version(struct_processus *s_	Line 970 instruction_version(struct_processus *s_
void	void
instruction_vars(struct_processus *s_etat_processus)	instruction_vars(struct_processus *s_etat_processus)
{	{
	integer8 i;
	integer8 nb_variables;

logical1 variable_partagee;	logical1 variable_partagee;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
Line 927 instruction_vars(struct_processus *s_eta	Line 980 instruction_vars(struct_processus *s_eta

struct_objet *s_objet_resultat;	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 971 instruction_vars(struct_processus *s_eta	Line 1024 instruction_vars(struct_processus *s_eta
(*s_objet_resultat).objet = NULL;	(*s_objet_resultat).objet = NULL;
l_element_precedent = NULL;	l_element_precedent = NULL;

#if 0	nb_variables = nombre_variables(s_etat_processus);
for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
	if ((tableau = malloc(((size_t) nb_variables) *
	sizeof(struct_tableau_variables))) == NULL)
	{
	liberation_mutexes_arbre_variables_partagees(s_etat_processus,
	((s_etat_processus).s_arbre_variables_partagees));
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	nb_variables = liste_variables(s_etat_processus, tableau);

	for(i = 0; i < nb_variables; i++)
{	{
if (l_element_precedent == NULL)	if (l_element_precedent == NULL)
{	{
Line 1022 instruction_vars(struct_processus *s_eta	Line 1087 instruction_vars(struct_processus *s_eta
* Mise en place d'un verrou si la variable est partagée.	* Mise en place d'un verrou si la variable est partagée.
*/	*/

if ((*s_etat_processus).s_liste_variables[i].objet == NULL)	if (tableau[i].objet == NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((*s_etat_processus).s_liste_variables[i]).nom,	tableau[i].nom, tableau[i].variable_partagee,
((*s_etat_processus).s_liste_variables[i])	tableau[i].origine) == NULL)
.variable_partagee, ((*s_etat_processus)
.s_liste_variables[i]).origine) == d_faux)
{	{
// La variable partagée n'existe plus.	// La variable partagée n'existe plus.

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

continue;	continue;
}	}

Line 1067 instruction_vars(struct_processus *s_eta	Line 1115 instruction_vars(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1084 instruction_vars(struct_processus *s_eta	Line 1138 instruction_vars(struct_processus *s_eta

if (((((struct_nom ) ((((struct_liste_chainee ) (((struct_objet *)	if (((((struct_nom ) ((((struct_liste_chainee ) (((struct_objet *)
(*l_element_courant).donnee)).objet)).donnee).objet)).nom =	(*l_element_courant).donnee)).objet)).donnee).objet)).nom =
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)	malloc((strlen(tableau[i].nom)
+ 1) * sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

strcpy((((struct_nom ) ((((struct_liste_chainee *)	strcpy((((struct_nom ) ((((struct_liste_chainee *)
(((struct_objet ) (*l_element_courant).donnee)).objet))	(((struct_objet ) (*l_element_courant).donnee)).objet))
.donnee).objet)).nom, (*s_etat_processus)	.donnee).objet)).nom, tableau[i].nom);
.s_liste_variables[i].nom);

/*	/*
* Préparation du niveau	* Préparation du niveau
Line 1117 instruction_vars(struct_processus *s_eta	Line 1176 instruction_vars(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1135 instruction_vars(struct_processus *s_eta	Line 1200 instruction_vars(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

(((integer8 ) (((((struct_liste_chainee ) (((struct_objet )	(((integer8 ) (((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =	(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
(integer8) (*s_etat_processus).s_liste_variables[i].niveau;	(integer8) tableau[i].niveau;

/*	/*
* Préparation du contenu de la variable	* Préparation du contenu de la variable
Line 1161 instruction_vars(struct_processus *s_eta	Line 1232 instruction_vars(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

if ((*s_etat_processus).s_liste_variables[i].objet == NULL)	if (tableau[i].objet == NULL)
{	{
// Variable partagée	// Variable partagée

if (((((((struct_liste_chainee ) (((struct_objet )	if (((((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.donnee = copie_objet(s_etat_processus,	.donnee = copie_objet(s_etat_processus,
((s_etat_processus)	((s_etat_processus).pointeur_variable_partagee_courante)
.s_liste_variables_partagees).table[((s_etat_processus)	.objet, 'P')) == NULL)
.s_liste_variables_partagees).position_variable].objet,
'P')) == NULL)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 1208 instruction_vars(struct_processus *s_eta	Line 1297 instruction_vars(struct_processus *s_eta

if (((((((struct_liste_chainee ) (((struct_objet )	if (((((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.donnee = copie_objet(s_etat_processus, (*s_etat_processus)	.donnee = copie_objet(s_etat_processus, tableau[i].objet,
.s_liste_variables[i].objet, 'P')) == NULL)	'P')) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1224 instruction_vars(struct_processus *s_eta	Line 1320 instruction_vars(struct_processus *s_eta
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.suivant = allocation_maillon(s_etat_processus)) == NULL)	.suivant = allocation_maillon(s_etat_processus)) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1232 instruction_vars(struct_processus *s_eta	Line 1334 instruction_vars(struct_processus *s_eta
(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
.donnee = allocation(s_etat_processus, CHN)) == NULL)	.donnee = allocation(s_etat_processus, CHN)) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

if (((*s_etat_processus).s_liste_variables[i].origine == 'P')	if ((tableau[i].origine == 'P')
? ((*s_etat_processus).s_liste_variables[i]	? (tableau[i].variable_statique.adresse != 0)
.variable_statique.adresse != 0)	: (tableau[i].variable_statique.pointeur != NULL))
: ((*s_etat_processus).s_liste_variables[i]
.variable_statique.pointeur != NULL))
{	{
if (((((((((struct_liste_chainee ) (((struct_objet )	if (((((((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.suivant).donnee).objet = malloc(7 *	.suivant).donnee).objet = malloc(7 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

strcpy((unsigned char ) (((((((struct_liste_chainee *)	if (tableau[i].variable_masquee == d_vrai)
(((struct_objet ) (*l_element_courant).donnee)).objet))	{
.suivant).suivant) .suivant).donnee).objet, "STATIC");	strcpy((unsigned char ) (((((((struct_liste_chainee *)
	(((struct_objet ) (*l_element_courant).donnee))
	.objet)).suivant).suivant).suivant).donnee).objet,
	"SHADOW");
	}
	else
	{
	strcpy((unsigned char ) (((((((struct_liste_chainee *)
	(((struct_objet ) (*l_element_courant).donnee))
	.objet)).suivant).suivant).suivant).donnee).objet,
	"STATIC");
	}
}	}
else	else
{	{
Line 1261 instruction_vars(struct_processus *s_eta	Line 1385 instruction_vars(struct_processus *s_eta
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.suivant).donnee).objet = malloc(9 *	.suivant).donnee).objet = malloc(9 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1280 instruction_vars(struct_processus *s_eta	Line 1411 instruction_vars(struct_processus *s_eta
.suivant).suivant = allocation_maillon(s_etat_processus))	.suivant).suivant = allocation_maillon(s_etat_processus))
== NULL)	== NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1289 instruction_vars(struct_processus *s_eta	Line 1426 instruction_vars(struct_processus *s_eta
.suivant).donnee = allocation(s_etat_processus, CHN))	.suivant).donnee = allocation(s_etat_processus, CHN))
== NULL)	== NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

if ((*s_etat_processus).s_liste_variables[i].variable_verrouillee	if (tableau[i].variable_verrouillee == d_vrai)
== d_vrai)
{	{
if ((((((((((struct_liste_chainee ) (((struct_objet *)	if ((((((((((struct_liste_chainee ) (((struct_objet *)
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.suivant).suivant).donnee).objet = malloc(7 *	.suivant).suivant).donnee).objet = malloc(7 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1317 instruction_vars(struct_processus *s_eta	Line 1466 instruction_vars(struct_processus *s_eta
.suivant).suivant).donnee).objet = malloc(9 *	.suivant).suivant).donnee).objet = malloc(9 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1328 instruction_vars(struct_processus *s_eta	Line 1484 instruction_vars(struct_processus *s_eta
}	}

/*	/*
* Préparation du drapeau PRIVATE/SHARED	* Préparation du drapeau PRIVATE/SHARED/MAPPED
*/	*/

if (((((((((struct_liste_chainee ) (((struct_objet )	if (((((((((struct_liste_chainee ) (((struct_objet )
Line 1336 instruction_vars(struct_processus *s_eta	Line 1492 instruction_vars(struct_processus *s_eta
.suivant).suivant).suivant =	.suivant).suivant).suivant =
allocation_maillon(s_etat_processus)) == NULL)	allocation_maillon(s_etat_processus)) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1345 instruction_vars(struct_processus *s_eta	Line 1507 instruction_vars(struct_processus *s_eta
.suivant).suivant).donnee = allocation(s_etat_processus,	.suivant).suivant).donnee = allocation(s_etat_processus,
CHN)) == NULL)	CHN)) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1356 instruction_vars(struct_processus *s_eta	Line 1524 instruction_vars(struct_processus *s_eta
.suivant).suivant).suivant).donnee).objet = malloc(7 *	.suivant).suivant).suivant).donnee).objet = malloc(7 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

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

	strcpy((unsigned char ) (((((((((struct_liste_chainee *)
	(((struct_objet ) (*l_element_courant).donnee)).objet))
	.suivant).suivant).suivant).suivant).suivant).donnee).objet,
	"MAPPED");
	}
	else if (tableau[i].mutex != NULL)
	{
	if (((((((((((struct_liste_chainee ) (((struct_objet )
	(*l_element_courant).donnee)).objet)).suivant).suivant)
	.suivant).suivant).suivant).donnee).objet = malloc(7 *
	sizeof(unsigned char))) == NULL)
	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1372 instruction_vars(struct_processus *s_eta	Line 1570 instruction_vars(struct_processus *s_eta
.suivant).suivant).suivant).donnee).objet = malloc(8 *	.suivant).suivant).suivant).donnee).objet = malloc(8 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 1391 instruction_vars(struct_processus *s_eta	Line 1596 instruction_vars(struct_processus *s_eta
.suivant).suivant).suivant).suivant = NULL;	.suivant).suivant).suivant).suivant = NULL;

l_element_precedent = l_element_courant;	l_element_precedent = l_element_courant;

	if (tableau[i].mutex != NULL)
	{
	// La variable est une variable partagée. On libère
	// le mutex.
	pthread_mutex_unlock(tableau[i].mutex);
	}
}	}
#endif
	free(tableau);

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 1423 instruction_visit(struct_processus *s_et	Line 1636 instruction_visit(struct_processus *s_et

struct_objet *s_objet;	struct_objet *s_objet;

unsigned long profondeur_initiale;	integer8 profondeur_initiale;

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.19
changed lines
	Added in v.1.85