rpl/src/evaluation.c - diff

Return to evaluation.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/evaluation.c between versions 1.60 and 1.111

version 1.60, 2012/10/04 15:21:25	version 1.111, 2019/01/01 09:02:50
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.11	RPL/2 (R) version 4.1.30
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

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

Line 48 evaluation(struct_processus *s_etat_proc	Line 48 evaluation(struct_processus *s_etat_proc
{	{
integer8 i;	integer8 i;
integer8 j;	integer8 j;
	integer8 k;
	integer8 l;
	integer8 niveau_initial;
	integer8 nombre_termes;
	integer8 registre_hauteur_pile_operationnelle;
	integer8 registre_position_courante;


logical1 drapeau_then;	logical1 drapeau_then;
logical1 erreur_evaluation;	logical1 erreur_evaluation;
Line 84 evaluation(struct_processus *s_etat_proc	Line 91 evaluation(struct_processus *s_etat_proc
unsigned char registre_evaluation_forcee;	unsigned char registre_evaluation_forcee;
unsigned char registre_instruction_valide;	unsigned char registre_instruction_valide;
unsigned char registre_mode_execution_programme;	unsigned char registre_mode_execution_programme;
unsigned char registre_retour_definition;
unsigned char registre_test;	unsigned char registre_test;
unsigned char registre_test_2;	unsigned char registre_test_2;
unsigned char registre_type_evaluation;	unsigned char registre_type_evaluation;

unsigned int registre_erreur_execution;	int registre_erreur_execution;
unsigned int registre_erreur_systeme;	int registre_erreur_systeme;
unsigned int registre_exception;	int registre_exception;

unsigned long k;
unsigned long l;
unsigned long n;
unsigned long niveau_initial;
unsigned long nombre_termes;
unsigned long registre_hauteur_pile_operationnelle;
unsigned long registre_niveau_courant;
unsigned long registre_position_courante;

void (*fonction)();	void (*fonction)();

Line 181 evaluation(struct_processus *s_etat_proc	Line 178 evaluation(struct_processus *s_etat_proc
{	{
// Variable partagée	// Variable partagée

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

presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
Line 196 evaluation(struct_processus *s_etat_proc	Line 185 evaluation(struct_processus *s_etat_proc
.pointeur_variable_courante).nom,	.pointeur_variable_courante).nom,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante)	.pointeur_variable_courante)
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') != NULL)
{	{
presence_variable = d_vrai;	presence_variable = d_vrai;
presence_variable_partagee = d_vrai;	presence_variable_partagee = d_vrai;

if (((((*s_etat_processus)	if ((((*s_etat_processus)
.s_liste_variables_partagees).table	.pointeur_variable_partagee_courante).objet)
[((s_etat_processus)	.type == ADR)
.s_liste_variables_partagees)
.position_variable].objet)).type
== ADR)
{	{
presence_fonction = d_vrai;	presence_fonction = d_vrai;
}	}
Line 214 evaluation(struct_processus *s_etat_proc	Line 200 evaluation(struct_processus *s_etat_proc
if ((s_copie_variable_partagee =	if ((s_copie_variable_partagee =
copie_objet(s_etat_processus,	copie_objet(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante).objet,
.table[((s_etat_processus)	'P')) == NULL)
.s_liste_variables_partagees)
.position_variable].objet, 'P')) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 235 evaluation(struct_processus *s_etat_proc	Line 219 evaluation(struct_processus *s_etat_proc
}	}

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 248 evaluation(struct_processus *s_etat_proc	Line 232 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
presence_variable = d_faux;	presence_variable = d_faux;
presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
return(d_erreur);
}
}	}
}	}
else	else
Line 309 evaluation(struct_processus *s_etat_proc	Line 285 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).autorisation_empilement_programme = 'N';	(*s_etat_processus).autorisation_empilement_programme = 'N';

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant = (*s_etat_processus)	.niveau_courant = (*s_etat_processus).niveau_courant;
.niveau_courant;

if (presence_variable_partagee == d_faux)	if (presence_variable_partagee == d_faux)
{	{
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 ) ((((*s_etat_processus)
((((*s_etat_processus).pointeur_variable_courante)	.pointeur_variable_courante).objet).objet)));
.objet).objet)));
}	}
else	else
{	{
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long ) (*s_copie_variable_partagee)	(((integer8 ) (*s_copie_variable_partagee)
.objet));	.objet));
liberation(s_etat_processus, s_copie_variable_partagee);	liberation(s_etat_processus, s_copie_variable_partagee);

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

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 357 evaluation(struct_processus *s_etat_proc	Line 323 evaluation(struct_processus *s_etat_proc

if (sequenceur(s_etat_processus) == d_erreur)	if (sequenceur(s_etat_processus) == d_erreur)
{	{
	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).evaluation_forcee =	(*s_etat_processus).evaluation_forcee =
registre_evaluation_forcee;	registre_evaluation_forcee;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
Line 409 evaluation(struct_processus *s_etat_proc	Line 377 evaluation(struct_processus *s_etat_proc

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

return(d_erreur);	return(d_erreur);
}	}
}	}
Line 453 evaluation(struct_processus *s_etat_proc	Line 410 evaluation(struct_processus *s_etat_proc
.niveau_courant = (*s_etat_processus)	.niveau_courant = (*s_etat_processus)
.niveau_courant;	.niveau_courant;

empilement_pile_systeme(s_etat_processus);

if (presence_variable_partagee == d_faux)	if (presence_variable_partagee == d_faux)
{	{
if (evaluation(s_etat_processus, ((s_etat_processus)	if (evaluation(s_etat_processus, ((s_etat_processus)
Line 466 evaluation(struct_processus *s_etat_proc	Line 421 evaluation(struct_processus *s_etat_proc
profilage(s_etat_processus, NULL);	profilage(s_etat_processus, NULL);
}	}

	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).evaluation_expression_compilee =	(*s_etat_processus).evaluation_expression_compilee =
registre_evaluation_expression_compilee;	registre_evaluation_expression_compilee;

Line 488 evaluation(struct_processus *s_etat_proc	Line 445 evaluation(struct_processus *s_etat_proc
profilage(s_etat_processus, NULL);	profilage(s_etat_processus, NULL);
}	}

	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).evaluation_expression_compilee =	(*s_etat_processus).evaluation_expression_compilee =
registre_evaluation_expression_compilee;	registre_evaluation_expression_compilee;

Line 507 evaluation(struct_processus *s_etat_proc	Line 466 evaluation(struct_processus *s_etat_proc
}	}

depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);
depilement_pile_systeme(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
Line 585 evaluation(struct_processus *s_etat_proc	Line 543 evaluation(struct_processus *s_etat_proc
}	}
else if (((s_objet).type == RPN) \|\| ((s_objet).type == ALG))	else if (((s_objet).type == RPN) \|\| ((s_objet).type == ALG))
{	{
// Ajout d'un bouchon à la liste des variables statiques pour
// savoir quelles sont les variables statiques qui ont été créées
// par l'évaluation de l'expression et qui sont susceptibles
// de devoir être éliminées.

if (ajout_bouchon_variable_statique(s_etat_processus) == d_erreur)
{
(*s_etat_processus).instruction_courante = instruction_courante;
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);
}

l_element_courant = (struct_liste_chainee ) (s_objet).objet;	l_element_courant = (struct_liste_chainee ) (s_objet).objet;
l_element_egalite = NULL;	l_element_egalite = NULL;
presence_egalite = d_faux;	presence_egalite = d_faux;
Line 767 evaluation(struct_processus *s_etat_proc	Line 713 evaluation(struct_processus *s_etat_proc
* Exécution de la séquence d'instructions	* Exécution de la séquence d'instructions
*/	*/

registre_retour_definition = ((s_etat_processus).l_base_pile_systeme)
.retour_definition;
((s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
((s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
s_objet;

l_element_courant = (struct_liste_chainee ) (s_objet).objet;	l_element_courant = (struct_liste_chainee ) (s_objet).objet;
autorisation_empilement_programme = (*s_etat_processus)	autorisation_empilement_programme = (*s_etat_processus)
.autorisation_empilement_programme;	.autorisation_empilement_programme;
Line 814 evaluation(struct_processus *s_etat_proc	Line 754 evaluation(struct_processus *s_etat_proc
((*s_etat_processus).erreur_systeme == d_es) &&	((*s_etat_processus).erreur_systeme == d_es) &&
((*s_etat_processus).exception == d_ep))	((*s_etat_processus).exception == d_ep))
{	{
	registre_evaluation_expression_compilee =
	(*s_etat_processus)
	.evaluation_expression_compilee;

	(*s_etat_processus).evaluation_expression_compilee
	= 'Y';

analyse(s_etat_processus, (((struct_fonction )	analyse(s_etat_processus, (((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.fonction);	.fonction);

	(*s_etat_processus).evaluation_expression_compilee =
	registre_evaluation_expression_compilee;

if (type_evaluation == 'I')	if (type_evaluation == 'I')
{	{
(*s_etat_processus).derniere_erreur_evaluation =	(*s_etat_processus).derniere_erreur_evaluation =
Line 836 evaluation(struct_processus *s_etat_proc	Line 786 evaluation(struct_processus *s_etat_proc
== 0)	== 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 2030 evaluation(struct_processus *s_etat_proc	Line 1981 evaluation(struct_processus *s_etat_proc
.var_volatile_processus_pere == 0)	.var_volatile_processus_pere == 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 2343 evaluation(struct_processus *s_etat_proc	Line 2295 evaluation(struct_processus *s_etat_proc
if (((s_etat_processus).pointeur_variable_courante).objet	if (((s_etat_processus).pointeur_variable_courante).objet
== NULL)	== NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante).nom,	.pointeur_variable_courante).nom,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante).variable_partagee,	.pointeur_variable_courante).variable_partagee,
'E') == d_vrai)	'E') != NULL)
{	{
// Une variable partagée existe.	// Une variable partagée existe.

Line 2363 evaluation(struct_processus *s_etat_proc	Line 2308 evaluation(struct_processus *s_etat_proc

((s_etat_processus).pointeur_variable_courante)	((s_etat_processus).pointeur_variable_courante)
.objet = ((s_etat_processus)	.objet = ((s_etat_processus)
.s_liste_variables_partagees).table	.pointeur_variable_partagee_courante)
[((s_etat_processus)	.objet;
.s_liste_variables_partagees)
.position_variable].objet;
}	}
else	else
{	{
presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
}
}	}
}	}
else	else
Line 2407 evaluation(struct_processus *s_etat_proc	Line 2343 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2441 evaluation(struct_processus *s_etat_proc	Line 2377 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2475 evaluation(struct_processus *s_etat_proc	Line 2411 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2515 evaluation(struct_processus *s_etat_proc	Line 2451 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2558 evaluation(struct_processus *s_etat_proc	Line 2494 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2595 evaluation(struct_processus *s_etat_proc	Line 2531 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2638 evaluation(struct_processus *s_etat_proc	Line 2574 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2701 evaluation(struct_processus *s_etat_proc	Line 2637 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2737 evaluation(struct_processus *s_etat_proc	Line 2673 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2774 evaluation(struct_processus *s_etat_proc	Line 2710 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2820 evaluation(struct_processus *s_etat_proc	Line 2756 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2856 evaluation(struct_processus *s_etat_proc	Line 2792 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2899 evaluation(struct_processus *s_etat_proc	Line 2835 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 2942 evaluation(struct_processus *s_etat_proc	Line 2878 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3005 evaluation(struct_processus *s_etat_proc	Line 2941 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3040 evaluation(struct_processus *s_etat_proc	Line 2976 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3093 evaluation(struct_processus *s_etat_proc	Line 3029 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3129 evaluation(struct_processus *s_etat_proc	Line 3065 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3148 evaluation(struct_processus *s_etat_proc	Line 3084 evaluation(struct_processus *s_etat_proc
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
}	}

	// Si l'objet élémentaire est un nom et que ce nom n'est
	// pas un nom symbolique, il convient de l'évaluer.

	if ((*s_objet_elementaire).type == NOM)
	{
	if (((((struct_nom ) (*s_objet_elementaire)
	.objet)).symbole == d_faux) \|\|
	(type_evaluation == 'N'))
	{
	if (evaluation(s_etat_processus,
	s_objet_elementaire, 'E') == d_erreur)
	{
	if (presence_variable_partagee == d_vrai)
	{
	((s_etat_processus)
	.pointeur_variable_courante)
	.objet = NULL;

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

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

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

	liberation(s_etat_processus,
	s_objet_elementaire);


	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_objet_elementaire) == d_erreur)
	{
	if (presence_variable_partagee == d_vrai)
	{
	((s_etat_processus)
	.pointeur_variable_courante)
	.objet = NULL;

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

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

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

/*	/*
Line 3172 evaluation(struct_processus *s_etat_proc	Line 3188 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3207 evaluation(struct_processus *s_etat_proc	Line 3223 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3248 evaluation(struct_processus *s_etat_proc	Line 3264 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3286 evaluation(struct_processus *s_etat_proc	Line 3302 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3305 evaluation(struct_processus *s_etat_proc	Line 3321 evaluation(struct_processus *s_etat_proc
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
}	}

	// Si l'objet élémentaire est un nom et que ce nom n'est
	// pas un nom symbolique, il convient de l'évaluer.

	if ((*s_objet_elementaire).type == NOM)
	{
	if (((((struct_nom ) (*s_objet_elementaire)
	.objet)).symbole == d_faux) \|\|
	(type_evaluation == 'N'))
	{
	if (evaluation(s_etat_processus,
	s_objet_elementaire, 'E') == d_erreur)
	{
	if (presence_variable_partagee == d_vrai)
	{
	((s_etat_processus)
	.pointeur_variable_courante)
	.objet = NULL;

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

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

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

	liberation(s_etat_processus,
	s_objet_elementaire);


	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_objet_elementaire) == d_erreur)
	{
	if (presence_variable_partagee == d_vrai)
	{
	((s_etat_processus)
	.pointeur_variable_courante)
	.objet = NULL;

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

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}
	}
	}
}	}
else if ((((((*s_etat_processus)	else if ((((((*s_etat_processus)
.pointeur_variable_courante).objet)).type == ALG) \|\|	.pointeur_variable_courante).objet)).type == ALG) \|\|
Line 3343 evaluation(struct_processus *s_etat_proc	Line 3439 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3380 evaluation(struct_processus *s_etat_proc	Line 3476 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3422 evaluation(struct_processus *s_etat_proc	Line 3518 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3435 evaluation(struct_processus *s_etat_proc	Line 3531 evaluation(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet_evalue);	liberation(s_etat_processus, s_objet_evalue);
}	}

	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
Line 3454 evaluation(struct_processus *s_etat_proc	Line 3552 evaluation(struct_processus *s_etat_proc
.niveau_courant;	.niveau_courant;

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 ) ((((*s_etat_processus)
((((*s_etat_processus)
.pointeur_variable_courante).objet).objet)));	.pointeur_variable_courante).objet).objet)));

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 3474 evaluation(struct_processus *s_etat_proc	Line 3571 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3506 evaluation(struct_processus *s_etat_proc	Line 3603 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3519 evaluation(struct_processus *s_etat_proc	Line 3616 evaluation(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet_evalue);	liberation(s_etat_processus, s_objet_evalue);
}	}

	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
Line 3543 evaluation(struct_processus *s_etat_proc	Line 3642 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.mutex)) != 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3578 evaluation(struct_processus *s_etat_proc	Line 3677 evaluation(struct_processus *s_etat_proc
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3609 evaluation(struct_processus *s_etat_proc	Line 3708 evaluation(struct_processus *s_etat_proc
NULL;	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 =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3641 evaluation(struct_processus *s_etat_proc	Line 3741 evaluation(struct_processus *s_etat_proc
NULL;	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 =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3664 evaluation(struct_processus *s_etat_proc	Line 3765 evaluation(struct_processus *s_etat_proc
.pointeur_variable_courante).objet = NULL;	.pointeur_variable_courante).objet = 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 =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 3716 evaluation(struct_processus *s_etat_proc	Line 3818 evaluation(struct_processus *s_etat_proc
.evaluation_expression_compilee;	.evaluation_expression_compilee;

(*s_etat_processus).evaluation_expression_compilee	(*s_etat_processus).evaluation_expression_compilee
= 'N';	= 'Y';

if (evaluation(s_etat_processus, (*l_element_courant)	if (evaluation(s_etat_processus, (*l_element_courant)
.donnee, type_evaluation) == d_erreur)	.donnee, type_evaluation) == d_erreur)
Line 3827 evaluation(struct_processus *s_etat_proc	Line 3929 evaluation(struct_processus *s_etat_proc
== 0)	== 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 4258 evaluation(struct_processus *s_etat_proc	Line 4361 evaluation(struct_processus *s_etat_proc

do	do
{	{
	l_element_courant = (*l_element_courant)
	.suivant;
l_registre_atome = l_element_courant;	l_registre_atome = l_element_courant;

if (l_element_courant == NULL)	if (l_element_courant == NULL)
Line 4297 evaluation(struct_processus *s_etat_proc	Line 4402 evaluation(struct_processus *s_etat_proc
drapeau_then = TEST(instruction_then)	drapeau_then = TEST(instruction_then)
? d_vrai : d_faux;	? d_vrai : d_faux;
}	}

l_element_courant = (*l_element_courant)
.suivant;
} while(drapeau_then == d_faux);	} while(drapeau_then == d_faux);

(*s_etat_processus).expression_courante =	(*s_etat_processus).expression_courante =
Line 5049 evaluation(struct_processus *s_etat_proc	Line 5151 evaluation(struct_processus *s_etat_proc
.var_volatile_processus_pere == 0)	.var_volatile_processus_pere == 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 5077 evaluation(struct_processus *s_etat_proc	Line 5180 evaluation(struct_processus *s_etat_proc
== 0)	== 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 5112 evaluation(struct_processus *s_etat_proc	Line 5216 evaluation(struct_processus *s_etat_proc

free(message);	free(message);

	l_registre_atome = l_element_courant;

while(((s_etat_processus).l_base_pile_systeme)	while(((s_etat_processus).l_base_pile_systeme)
.clause != 'R')	.clause != 'R')
{	{
Line 5508 evaluation(struct_processus *s_etat_proc	Line 5614 evaluation(struct_processus *s_etat_proc

do	do
{	{
	(*s_etat_processus).expression_courante =
	l_registre_atome;
l_registre_atome = l_element_courant;	l_registre_atome = l_element_courant;

if (l_element_courant == NULL)	if (l_element_courant == NULL)
Line 5552 evaluation(struct_processus *s_etat_proc	Line 5660 evaluation(struct_processus *s_etat_proc
.suivant;	.suivant;
} while(drapeau_then == d_faux);	} while(drapeau_then == d_faux);

(*s_etat_processus).expression_courante =
l_registre_atome;

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.clause = 'X';	.clause = 'X';
instruction_then(s_etat_processus);	instruction_then(s_etat_processus);
Line 6289 evaluation(struct_processus *s_etat_proc	Line 6394 evaluation(struct_processus *s_etat_proc
registre_mode_execution_programme;	registre_mode_execution_programme;
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
{	{
liberation(s_etat_processus, s_objet_evalue);	liberation(s_etat_processus, s_objet_evalue);
Line 6299 evaluation(struct_processus *s_etat_proc	Line 6403 evaluation(struct_processus *s_etat_proc
.var_volatile_processus_pere == 0)	.var_volatile_processus_pere == 0)
{	{
envoi_signal_processus((*s_etat_processus)	envoi_signal_processus((*s_etat_processus)
.pid_processus_pere, rpl_sigalrm);	.pid_processus_pere, rpl_sigalrm,
	d_faux);
}	}
else	else
{	{
Line 6380 evaluation(struct_processus *s_etat_proc	Line 6485 evaluation(struct_processus *s_etat_proc
{	{
// Variable partagée	// Variable partagée

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

presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (recherche_variable_partagee(	if (recherche_variable_partagee(
Line 6396 evaluation(struct_processus *s_etat_proc	Line 6492 evaluation(struct_processus *s_etat_proc
.pointeur_variable_courante).nom,	.pointeur_variable_courante).nom,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante)	.pointeur_variable_courante)
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') != NULL)
{	{
presence_variable = d_vrai;	presence_variable = d_vrai;
presence_variable_partagee = d_vrai;	presence_variable_partagee = d_vrai;

if (((((*s_etat_processus)	if ((((*s_etat_processus)
.s_liste_variables_partagees).table	.pointeur_variable_partagee_courante
[((s_etat_processus)	).objet).type == ADR)
.s_liste_variables_partagees)
.position_variable].objet)).type
== ADR)
{	{
presence_fonction = d_vrai;	presence_fonction = d_vrai;
}	}
Line 6417 evaluation(struct_processus *s_etat_proc	Line 6510 evaluation(struct_processus *s_etat_proc
.objet)).symbole == d_faux))	.objet)).symbole == d_faux))
{	{
if ((s_copie_variable_partagee =	if ((s_copie_variable_partagee =
copie_objet(s_etat_processus,	copie_objet(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.table[((s_etat_processus)	).objet, 'P')) == NULL)
.s_liste_variables_partagees)
.position_variable].objet, 'P'))
== NULL)
{	{
if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees	.pointeur_variable_partagee_courante
).mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus)	(*s_etat_processus)
.erreur_systeme =	.erreur_systeme =
Line 6444 evaluation(struct_processus *s_etat_proc	Line 6534 evaluation(struct_processus *s_etat_proc

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
Line 6457 evaluation(struct_processus *s_etat_proc	Line 6547 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
presence_variable = d_faux;	presence_variable = d_faux;
presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (pthread_mutex_unlock(
&(((s_etat_processus)
.s_liste_variables_partagees)
.mutex)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
return(d_erreur);
}
}	}
}	}
else	else
Line 6564 evaluation(struct_processus *s_etat_proc	Line 6644 evaluation(struct_processus *s_etat_proc
if (presence_variable_partagee == d_faux)	if (presence_variable_partagee == d_faux)
{	{
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 )
((((*s_etat_processus)	((((*s_etat_processus)
.pointeur_variable_courante)	.pointeur_variable_courante)
.objet).objet)));	.objet).objet)));
Line 6572 evaluation(struct_processus *s_etat_proc	Line 6652 evaluation(struct_processus *s_etat_proc
else	else
{	{
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 )
(*s_copie_variable_partagee).objet));	(*s_copie_variable_partagee).objet));
liberation(s_etat_processus,	liberation(s_etat_processus,
s_copie_variable_partagee);	s_copie_variable_partagee);
Line 6609 evaluation(struct_processus *s_etat_proc	Line 6689 evaluation(struct_processus *s_etat_proc
s_objet_evalue);	s_objet_evalue);
}	}

	depilement_pile_systeme(s_etat_processus);

(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
Line 6617 evaluation(struct_processus *s_etat_proc	Line 6699 evaluation(struct_processus *s_etat_proc
}	}

(*s_etat_processus).evaluation_forcee =	(*s_etat_processus).evaluation_forcee =
registre_evaluation_forcee;	registre_evaluation_forcee;
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;
(*s_etat_processus).mode_execution_programme = 'N';	(*s_etat_processus).mode_execution_programme = 'N';
Line 6752 evaluation(struct_processus *s_etat_proc	Line 6834 evaluation(struct_processus *s_etat_proc
}	}
}	}

registre_niveau_courant = ((s_etat_processus)	empilement_pile_systeme(s_etat_processus);
.l_base_pile_systeme).niveau_courant;
registre_retour_definition =
((s_etat_processus)
.l_base_pile_systeme).retour_definition;

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition = 'Y';	.retour_definition = 'Y';
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant = (*s_etat_processus)	.niveau_courant = (*s_etat_processus)
.niveau_courant;	.niveau_courant;
empilement_pile_systeme(s_etat_processus);	((s_etat_processus).l_base_pile_systeme)
	.pointeur_objet_retour =
	l_element_courant;
	((s_etat_processus).l_base_pile_systeme)
	.origine_routine_evaluation = 'Y';

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
Line 6772 evaluation(struct_processus *s_etat_proc	Line 6854 evaluation(struct_processus *s_etat_proc
{	{
depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);

((s_etat_processus).l_base_pile_systeme)
.niveau_courant =
registre_niveau_courant;
((s_etat_processus).l_base_pile_systeme)
.retour_definition =
registre_retour_definition;

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus, NULL);	profilage(s_etat_processus, NULL);
Line 6803 evaluation(struct_processus *s_etat_proc	Line 6878 evaluation(struct_processus *s_etat_proc

depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);

	if ((((*s_etat_processus).erreur_execution !=
	d_ex) \|\| ((*s_etat_processus)
	.erreur_systeme != d_es)) &&
	((*s_etat_processus).arret_si_exception
	== d_faux))
	{
	// Reprise sur erreur.

	//==============================================================================
	// Réindentation
	//==============================================================================

	drapeau_then = d_faux;

	while(drapeau_then == d_faux)
	{
	l_registre_atome = l_element_courant;
	l_element_courant = (*l_element_courant).suivant;

	if (l_element_courant == NULL)
	{
	/*
	* La fin de l'expression est atteinte,
	* le sequenceur reprend la main.
	*/

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus, s_objet_evalue);
	}

	(*s_etat_processus).mode_execution_programme =
	registre_mode_execution_programme;
	return(d_absence_erreur);
	}

	if (((l_element_courant).donnee).type == FCT)
	{
	(*s_etat_processus).instruction_courante =
	(((struct_fonction )
	((l_element_courant).donnee)
	.objet)).nom_fonction;

	if (recherche_variable(s_etat_processus,
	(*s_etat_processus).instruction_courante) == d_faux)
	{
	(*s_etat_processus).erreur_systeme = d_es;
	fonction = (((struct_fonction )
	((l_element_courant).donnee)
	.objet)).fonction;

	/*
	* Traitement de la pile système par les
	* différentes instructions.
	*/

	if (TEST(instruction_if) \|\|
	TEST(instruction_iferr) \|\|
	TEST(instruction_do) \|\|
	TEST(instruction_while) \|\|
	TEST(instruction_for) \|\|
	TEST(instruction_forall) \|\|
	TEST(instruction_start) \|\|
	TEST(instruction_select) \|\|
	TEST(instruction_case) \|\|
	TEST(instruction_critical) \|\|
	TEST(vers_niveau_superieur))
	{
	if (TEST(vers_niveau_superieur))
	{
	registre_exception = (*s_etat_processus)
	.exception;
	registre_erreur_execution = (*s_etat_processus)
	.erreur_execution;

	analyse(s_etat_processus,
	vers_niveau_superieur);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}

	(*s_etat_processus).exception
	= registre_exception;
	(*s_etat_processus).erreur_execution =
	registre_erreur_execution;
	}
	else if (TEST(instruction_for) \|\|
	TEST(instruction_forall) \|\|
	TEST(instruction_start))
	{
	empilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant =	.type_cloture = 'L';
registre_niveau_courant;	}
	else
	{
	empilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}
	}
	}
	else if (TEST(instruction_end) \|\|
	TEST(instruction_next) \|\|
	TEST(instruction_step) \|\|
	TEST(vers_niveau_inferieur))
	{
	if (TEST(vers_niveau_inferieur))
	{
	registre_exception = (*s_etat_processus)
	.exception;
	registre_erreur_execution = (*s_etat_processus)
	.erreur_execution;

	analyse(s_etat_processus,
	vers_niveau_inferieur);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}

	(*s_etat_processus).exception
	= registre_exception;
	(*s_etat_processus).erreur_execution =
	registre_erreur_execution;
	}
	else if ((TEST(instruction_next) \|\|
	TEST(instruction_step)) &&
	(((s_etat_processus)
	.l_base_pile_systeme)
	.type_cloture != 'L'))
	{
	/*
	* Libération des compteurs
	* de boucle
	*/

	presence_compteur = ((((s_etat_processus)
	.l_base_pile_systeme).type_cloture == 'F')
	\|\| (((s_etat_processus)
	.l_base_pile_systeme).type_cloture == 'A'))
	? d_vrai : d_faux;

	if ((((s_etat_processus).l_base_pile_systeme)
	.type_cloture != 'S') && (presence_compteur
	== d_faux))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_traitement_boucle;

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}

	if (presence_compteur == d_vrai)
	{
	if (recherche_variable(s_etat_processus,
	((s_etat_processus)
	.l_base_pile_systeme).nom_variable)
	== d_faux)
	{
	(*s_etat_processus).erreur_systeme =
	d_es;
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_traitement_boucle;

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante
	= instruction_courante;
	return(d_erreur);
	}

	if (((s_etat_processus)
	.pointeur_variable_courante)
	.objet == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es;
	(*s_etat_processus).erreur_execution =
	d_ex_variable_partagee;

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante
	= instruction_courante;
	return(d_erreur);
	}

	(*s_etat_processus)
	.niveau_courant--;

	if (retrait_variables_par_niveau(
	s_etat_processus) == d_erreur)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante = instruction_courante;
	return(d_erreur);
	}
	}

	depilement_pile_systeme(s_etat_processus);
	}
	else
	{
	// Traitement spécifique pour
	// la fin d'une section
	// critique

	if ((*s_etat_processus).l_base_pile_systeme
	== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_end_incoherent;

	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}

	if (((s_etat_processus).l_base_pile_systeme)
	.type_cloture == 'Q')
	{
	if (pthread_mutex_unlock(
	&mutex_sections_critiques) != 0)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_processus;

	liberation(s_etat_processus,
	s_objet_evalue);

	(*s_etat_processus).instruction_courante = instruction_courante;
	return(d_erreur);
	}

	(*s_etat_processus).sections_critiques--;
	}

	depilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus)
	.erreur_systeme != d_es)
	{
	if (presence_egalite == d_vrai)
	{
	liberation(s_etat_processus,
	s_objet_evalue);
	}

	(*s_etat_processus).instruction_courante =
	instruction_courante;
	return(d_erreur);
	}
	}
	}
	else if (TEST(instruction_then))
	{
	if (((s_etat_processus).l_base_pile_systeme)
	.clause == 'R')
	{
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition =	.clause = 'X';
registre_retour_definition;	instruction_then(s_etat_processus);
	drapeau_then = d_vrai;
	}
	}
	}
	}
	}

	(*s_etat_processus).expression_courante =
	l_element_courant;
	(*s_etat_processus).instruction_courante =
	instruction_courante;

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

	//==============================================================================
	// Fin de la réindentation
	//==============================================================================
	}
}	}
else	else
{	{
Line 6831 evaluation(struct_processus *s_etat_proc	Line 7252 evaluation(struct_processus *s_etat_proc
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant = (*s_etat_processus)	.niveau_courant = (*s_etat_processus)
.niveau_courant;	.niveau_courant;
empilement_pile_systeme(s_etat_processus);

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
s_copie_variable_partagee,	s_copie_variable_partagee,
type_evaluation) == d_erreur)	type_evaluation) == d_erreur)
{	{
depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);
depilement_pile_systeme(s_etat_processus);

liberation(s_etat_processus,	liberation(s_etat_processus,
s_copie_variable_partagee);	s_copie_variable_partagee);
Line 6866 evaluation(struct_processus *s_etat_proc	Line 7285 evaluation(struct_processus *s_etat_proc
}	}

depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);
depilement_pile_systeme(s_etat_processus);

liberation(s_etat_processus,	liberation(s_etat_processus,
s_copie_variable_partagee);	s_copie_variable_partagee);
Line 6926 evaluation(struct_processus *s_etat_proc	Line 7344 evaluation(struct_processus *s_etat_proc
{	{
// Variable partagée	// Variable partagée

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

if (recherche_variable_partagee(	if (recherche_variable_partagee(
s_etat_processus,	s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante).nom,	.pointeur_variable_courante).nom,
((s_etat_processus)	((s_etat_processus)
.pointeur_variable_courante)	.pointeur_variable_courante)
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') != NULL)
{	{
liberation(s_etat_processus,	liberation(s_etat_processus,
s_objet_elementaire);	s_objet_elementaire);

if ((s_objet_elementaire =	if ((s_objet_elementaire =
copie_objet(s_etat_processus,	copie_objet(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.table[((s_etat_processus)	).objet, 'P')) == NULL)
.s_liste_variables_partagees)
.position_variable].objet,
'P')) == NULL)
{	{
if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees	.pointeur_variable_partagee_courante
).mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus)	(*s_etat_processus)
.erreur_systeme =	.erreur_systeme =
Line 6980 evaluation(struct_processus *s_etat_proc	Line 7385 evaluation(struct_processus *s_etat_proc
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
}	}
}

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante
.mutex)) != 0)	).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
return(d_erreur);	return(d_erreur);
	}
}	}
}	}
else	else
Line 7201 evaluation(struct_processus *s_etat_proc	Line 7606 evaluation(struct_processus *s_etat_proc
* Retrait des variables statiques créées dans l'expression	* Retrait des variables statiques créées dans l'expression
*/	*/

if (retrait_variables_statiques(s_etat_processus) == d_erreur)	if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
{	{
if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
{	{
Line 7219 evaluation(struct_processus *s_etat_proc	Line 7624 evaluation(struct_processus *s_etat_proc
* Retrait des variables partagées créées dans l'expression	* Retrait des variables partagées créées dans l'expression
*/	*/

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

for(n = 0; n < ((s_etat_processus).s_liste_variables_partagees)
.nombre_variables; n++)
{	{
if (((s_etat_processus).s_liste_variables_partagees).table[n]	if (presence_egalite == d_vrai)
.niveau > (*s_etat_processus).niveau_courant)
{	{
if (retrait_variable_partagee(s_etat_processus,	liberation(s_etat_processus, s_objet_evalue);
((s_etat_processus).s_liste_variables_partagees)
.table[n].nom, ((s_etat_processus)
.s_liste_variables_partagees).table[n]
.variable_partagee) == d_erreur)
{
if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_erreur);
}

if (presence_egalite == d_vrai)
{
liberation(s_etat_processus, s_objet_evalue);
}

(*s_etat_processus).instruction_courante =
instruction_courante;
(*s_etat_processus).mode_execution_programme =
registre_mode_execution_programme;
return(d_erreur);
}
}	}
}

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

Line 7298 evaluation(struct_processus *s_etat_proc	Line 7670 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
autorisation_empilement_programme;	autorisation_empilement_programme;
(*s_etat_processus).instruction_courante = instruction_courante;	(*s_etat_processus).instruction_courante = instruction_courante;
((s_etat_processus).l_base_pile_systeme).retour_definition =
registre_retour_definition;

return(d_erreur);	return(d_erreur);
}	}

Line 7313 evaluation(struct_processus *s_etat_proc	Line 7682 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
autorisation_empilement_programme;	autorisation_empilement_programme;
(*s_etat_processus).instruction_courante = instruction_courante;	(*s_etat_processus).instruction_courante = instruction_courante;
((s_etat_processus).l_base_pile_systeme).retour_definition =
registre_retour_definition;

return(d_erreur);	return(d_erreur);
}	}
}	}
Line 7323 evaluation(struct_processus *s_etat_proc	Line 7689 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
autorisation_empilement_programme;	autorisation_empilement_programme;
(*s_etat_processus).instruction_courante = instruction_courante;	(*s_etat_processus).instruction_courante = instruction_courante;
((s_etat_processus).l_base_pile_systeme).retour_definition =
registre_retour_definition;
}	}
else if ((*s_objet).type == FCT)	else if ((*s_objet).type == FCT)
{	{
Line 7333 evaluation(struct_processus *s_etat_proc	Line 7697 evaluation(struct_processus *s_etat_proc

registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)	registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
? 'E' : 'N';	? 'E' : 'N';
cf(s_etat_processus, 35);
	if (type_evaluation == 'N')
	{
	cf(s_etat_processus, 35);
	}
	else
	{
	sf(s_etat_processus, 35);
	}

analyse(s_etat_processus, (((struct_fonction )	analyse(s_etat_processus, (((struct_fonction )
(*s_objet).objet)).fonction);	(*s_objet).objet)).fonction);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.60
changed lines
	Added in v.1.111