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.7 and 1.85

version 1.7, 2010/04/21 13:45:49	version 1.85, 2025/04/15 10:17:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.15	RPL/2 (R) version 4.1.36
Copyright (C) 1989-2010 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 20	Line 20
*/	*/


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


/*	/*
Line 38	Line 38
void	void
instruction_var(struct_processus *s_etat_processus)	instruction_var(struct_processus *s_etat_processus)
{	{
logical1 presence_variable;

long i;

struct_objet *s_objet_statistique;	struct_objet *s_objet_statistique;
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 85 instruction_var(struct_processus *s_etat	Line 81 instruction_var(struct_processus *s_etat
* Recherche d'une variable globale référencée par SIGMA	* Recherche d'une variable globale référencée par SIGMA
*/	*/

if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)	if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
{	{
/*	/*
* Aucune variable SIGMA	* Aucune variable SIGMA
*/	*/

(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
(*s_etat_processus).erreur_execution = d_ex_absence_observations;
return;
}
else
{
/*
* Il existe une variable locale SIGMA. Reste à vérifier l'existence
* d'une variable SIGMA globale...
*/

i = (*s_etat_processus).position_variable_courante;	if ((*s_etat_processus).erreur_execution == d_ex)
presence_variable = d_faux;

while(i >= 0)
{	{
if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,	(*s_etat_processus).erreur_execution = d_ex_absence_observations;
ds_sdat) == 0) && ((*s_etat_processus)
.s_liste_variables[i].niveau == 1))
{
presence_variable = d_vrai;
break;
}

i--;
}	}

if (presence_variable == d_faux)	return;
	}
	else
	{
	if (((((*s_etat_processus).pointeur_variable_courante).objet)
	.type != MIN) && ((((*s_etat_processus)
	.pointeur_variable_courante).objet).type != MRL))
{	{
(*s_etat_processus).erreur_execution = d_ex_absence_observations;	(*s_etat_processus).erreur_execution =
	d_ex_matrice_statistique_invalide;
return;	return;
}	}
else
{
(*s_etat_processus).position_variable_courante = i;

if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
{
(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
return;
}

if (((((s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante].objet))
.type != MIN) && ((((s_etat_processus)
.s_liste_variables[(*s_etat_processus)
.position_variable_courante].objet)).type != MRL))
{
(*s_etat_processus).erreur_execution =
d_ex_matrice_statistique_invalide;
return;
}

nombre_colonnes = (((struct_matrice ) (((s_etat_processus)	nombre_colonnes = (((struct_matrice ) (((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet).objet))
.position_variable_courante].objet)).objet))	.nombre_colonnes;
.nombre_colonnes;
}
}	}

s_objet_statistique = ((*s_etat_processus).s_liste_variables	s_objet_statistique = ((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]).objet;	.objet;

if (((*s_objet_statistique).type == MIN) \|\|	if (((*s_objet_statistique).type == MIN) \|\|
((*s_objet_statistique).type == MRL))	((*s_objet_statistique).type == MRL))
Line 171 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 276 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 538 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 869 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 878 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 888 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 930 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 959 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 966 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 1010 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;

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

	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 1060 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 1105 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 1122 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 1155 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 1173 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 1199 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 1246 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 1262 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 1270 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 1299 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 1318 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 1327 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 1355 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 1366 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 1374 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 1383 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 1394 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 1410 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 1429 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);
	}
}	}

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

Line 1641 instruction_visit(struct_processus *s_et	Line 1817 instruction_visit(struct_processus *s_et
void	void
instruction_variable(struct_processus *s_etat_processus)	instruction_variable(struct_processus *s_etat_processus)
{	{
logical1 presence_variable;

long i;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

struct_objet *s_objet;	struct_objet *s_objet;
Line 1691 instruction_variable(struct_processus *s	Line 1863 instruction_variable(struct_processus *s

if ((*s_objet).type == NOM)	if ((*s_objet).type == NOM)
{	{
if (recherche_variable(s_etat_processus, ((((struct_nom )	if (recherche_variable_globale(s_etat_processus, ((((struct_nom )
(*s_objet).objet)).nom)) == d_faux)	(*s_objet).objet)).nom)) == d_faux)
{	{
liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);
Line 1701 instruction_variable(struct_processus *s	Line 1873 instruction_variable(struct_processus *s
return;	return;
}	}

i = (*s_etat_processus).position_variable_courante;	((s_etat_processus).pointeur_variable_courante)
presence_variable = d_faux;	.variable_verrouillee = d_faux;

while(i >= 0)
{
if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
(((struct_nom ) (*s_objet).objet)).nom) == 0)
&& ((*s_etat_processus).s_liste_variables[i].niveau == 1))
{
presence_variable = d_vrai;
break;
}

i--;
}

(*s_etat_processus).position_variable_courante = i;

if (presence_variable == d_faux)
{
liberation(s_etat_processus, s_objet);

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

((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante]).variable_verrouillee = d_faux;
}	}
else if ((*s_objet).type == LST)	else if ((*s_objet).type == LST)
{	{
Line 1744 instruction_variable(struct_processus *s	Line 1890 instruction_variable(struct_processus *s
return;	return;
}	}

if (recherche_variable(s_etat_processus, (((struct_nom )	if (recherche_variable_globale(s_etat_processus, (((struct_nom )
((l_element_courant).donnee).objet)).nom) == d_faux)	((l_element_courant).donnee).objet)).nom) == d_faux)
{	{
liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);
Line 1755 instruction_variable(struct_processus *s	Line 1901 instruction_variable(struct_processus *s
return;	return;
}	}

i = (*s_etat_processus).position_variable_courante;	((s_etat_processus).pointeur_variable_courante)
presence_variable = d_faux;	.variable_verrouillee = d_faux;

while(i >= 0)
{
if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
(((struct_nom ) ((l_element_courant).donnee)
.objet)).nom) == 0) && ((*s_etat_processus)
.s_liste_variables[i].niveau == 1))
{
presence_variable = d_vrai;
break;
}

i--;
}

(*s_etat_processus).position_variable_courante = i;

if (presence_variable == d_faux)
{
liberation(s_etat_processus, s_objet);

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

((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante]).variable_verrouillee = d_faux;

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

CVSweb interface <joel.bertrand@systella.fr>

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