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.84 and 1.103

version 1.84, 2014/07/17 08:07:17	version 1.103, 2016/09/27 15:29:32
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.19	RPL/2 (R) version 4.1.26
Copyright (C) 1989-2014 Dr. BERTRAND Joël	Copyright (C) 1989-2016 Dr. BERTRAND Joël

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

Line 31	Line 31
================================================================================	================================================================================
Evaluation d'une expression	Evaluation d'une expression
================================================================================	================================================================================
Entrées :	EntrÃ©es :
structure processus,	structure processus,
objet à évaluer (non libéré au retour de la routine)	objet Ã Ã©valuer (non libÃ©rÃ© au retour de la routine)
et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')	et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Sorties : objet évalué au niveau 1 de la pile	Sorties : objet Ã©valuÃ© au niveau 1 de la pile
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Effets de bord : néant	Effets de bord : nÃ©ant
================================================================================	================================================================================
*/	*/

Line 176 evaluation(struct_processus *s_etat_proc	Line 176 evaluation(struct_processus *s_etat_proc
if (((s_etat_processus).pointeur_variable_courante)	if (((s_etat_processus).pointeur_variable_courante)
.objet == NULL)	.objet == NULL)
{	{
// Variable partagée	// Variable partagÃ©e

presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

Line 236 evaluation(struct_processus *s_etat_proc	Line 236 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Variable privée	// Variable privÃ©e

presence_variable = d_vrai;	presence_variable = d_vrai;

Line 571 evaluation(struct_processus *s_etat_proc	Line 571 evaluation(struct_processus *s_etat_proc

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
{	{
// S'il y a un signe '=', on modifie l'expression à évaluer en ôtant	// S'il y a un signe '=', on modifie l'expression Ã Ã©valuer en Ã´tant
// le signe '=' et en le remplaçant d'une part par SWAP DROP	// le signe '=' et en le remplaÃ§ant d'une part par SWAP DROP
// et d'autre part par DROP. On évalue la première puis la	// et d'autre part par DROP. On Ã©value la premiÃ¨re puis la
// seconde normalement avant de reconstituer le tout à la fin	// seconde normalement avant de reconstituer le tout Ã la fin
// de la routine.	// de la routine.

l_registre_pile_operationnelle = NULL;	l_registre_pile_operationnelle = NULL;
Line 633 evaluation(struct_processus *s_etat_proc	Line 633 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

// Récupération de l'objet au niveau 1 résultat de l'évaluation	// RÃ©cupÃ©ration de l'objet au niveau 1 rÃ©sultat de l'Ã©valuation
// du premier membre de l'équation puis destruction de la pile.	// du premier membre de l'Ã©quation puis destruction de la pile.

if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet_evalue) == d_erreur)	&s_objet_evalue) == d_erreur)
Line 646 evaluation(struct_processus *s_etat_proc	Line 646 evaluation(struct_processus *s_etat_proc

instruction_clear(s_etat_processus);	instruction_clear(s_etat_processus);

// Régénération de la pile initiale	// RÃ©gÃ©nÃ©ration de la pile initiale

while(depilement(s_etat_processus, &l_registre_pile_operationnelle,	while(depilement(s_etat_processus, &l_registre_pile_operationnelle,
&s_sous_objet) != d_erreur)	&s_sous_objet) != d_erreur)
Line 710 evaluation(struct_processus *s_etat_proc	Line 710 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Exécution de la séquence d'instructions	* ExÃ©cution de la sÃ©quence d'instructions
*/	*/

l_element_courant = (struct_liste_chainee ) (s_objet).objet;	l_element_courant = (struct_liste_chainee ) (s_objet).objet;
Line 731 evaluation(struct_processus *s_etat_proc	Line 731 evaluation(struct_processus *s_etat_proc
if (((l_element_courant).donnee).type == FCT)	if (((l_element_courant).donnee).type == FCT)
{	{
/*	/*
* Tester la cohérence avec une variable pour récupérer les	* Tester la cohÃ©rence avec une variable pour rÃ©cupÃ©rer les
* données selon les indices passés en argument (tableaux,	* donnÃ©es selon les indices passÃ©s en argument (tableaux,
* listes...).	* listes...).
*/	*/

Line 758 evaluation(struct_processus *s_etat_proc	Line 758 evaluation(struct_processus *s_etat_proc
(*s_etat_processus)	(*s_etat_processus)
.evaluation_expression_compilee;	.evaluation_expression_compilee;

if ((((s_etat_processus).pointeur_variable_courante)	(*s_etat_processus).evaluation_expression_compilee
.origine == 'E') && (((s_etat_processus)	= 'Y';
.pointeur_variable_courante).niveau == 0))
{
(*s_etat_processus).evaluation_expression_compilee
= 'Y';
}
else
{
(*s_etat_processus).evaluation_expression_compilee
= 'N';
}

analyse(s_etat_processus, (((struct_fonction )	analyse(s_etat_processus, (((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 796 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 876 evaluation(struct_processus *s_etat_proc	Line 867 evaluation(struct_processus *s_etat_proc
.objet)).fonction;	.objet)).fonction;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 1025 evaluation(struct_processus *s_etat_proc	Line 1016 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 1142 evaluation(struct_processus *s_etat_proc	Line 1133 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour	// Traitement spÃ©cifique pour
// la fin d'une section	// la fin d'une section
// critique	// critique

Line 1268 evaluation(struct_processus *s_etat_proc	Line 1259 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 1391 evaluation(struct_processus *s_etat_proc	Line 1382 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 1508 evaluation(struct_processus *s_etat_proc	Line 1499 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour	// Traitement spÃ©cifique pour
// la fin d'une section	// la fin d'une section
// critique	// critique

Line 1607 evaluation(struct_processus *s_etat_proc	Line 1598 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// On ne détruit pas les variables pour les inclure	// On ne dÃ©truit pas les variables pour les inclure
// dans le fichier rpl-core.	// dans le fichier rpl-core.

(*s_etat_processus).gel_liste_variables = d_vrai;	(*s_etat_processus).gel_liste_variables = d_vrai;
Line 1645 evaluation(struct_processus *s_etat_proc	Line 1636 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 1776 evaluation(struct_processus *s_etat_proc	Line 1767 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 1893 evaluation(struct_processus *s_etat_proc	Line 1884 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour	// Traitement spÃ©cifique pour
// la fin d'une section critique	// la fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 1990 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 2015 evaluation(struct_processus *s_etat_proc	Line 2007 evaluation(struct_processus *s_etat_proc
else	else
{	{
/*	/*
* Régénération de la fonction en notation algébrique	* RÃ©gÃ©nÃ©ration de la fonction en notation algÃ©brique
*/	*/

if ((s_objet_elementaire = (struct_objet *)	if ((s_objet_elementaire = (struct_objet *)
Line 2201 evaluation(struct_processus *s_etat_proc	Line 2193 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Clôture de l'expression	* ClÃ´ture de l'expression
*/	*/

if (((*l_element_fonction).suivant =	if (((*l_element_fonction).suivant =
Line 2310 evaluation(struct_processus *s_etat_proc	Line 2302 evaluation(struct_processus *s_etat_proc
.pointeur_variable_courante).variable_partagee,	.pointeur_variable_courante).variable_partagee,
'E') != NULL)	'E') != NULL)
{	{
// Une variable partagée existe.	// Une variable partagÃ©e existe.

presence_variable_partagee = d_vrai;	presence_variable_partagee = d_vrai;

Line 2330 evaluation(struct_processus *s_etat_proc	Line 2322 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Recherche d'un élément dans un vecteur	* Recherche d'un Ã©lÃ©ment dans un vecteur
*/	*/

if (((s_etat_processus).pointeur_variable_courante)	if (((s_etat_processus).pointeur_variable_courante)
.objet == NULL)	.objet == NULL)
{	{
// La variable partagée n'existe plus.	// La variable partagÃ©e n'existe plus.

free(s_objet_elementaire);	free(s_objet_elementaire);

Line 2620 evaluation(struct_processus *s_etat_proc	Line 2612 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Recherche d'un élément dans une matrice	* Recherche d'un Ã©lÃ©ment dans une matrice
*/	*/

else if (((((((*s_etat_processus)	else if (((((((*s_etat_processus)
Line 2928 evaluation(struct_processus *s_etat_proc	Line 2920 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Recherche de l'élément idoine dans la liste	* Recherche de l'Ã©lÃ©ment idoine dans la liste
*/	*/

else if ((((((*s_etat_processus)	else if ((((((*s_etat_processus)
Line 3092 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);
	}
	}
	}
}	}

/*	/*
* Recherche de l'élément idoine dans la table	* Recherche de l'Ã©lÃ©ment idoine dans la table
*/	*/

else if ((((((*s_etat_processus)	else if ((((((*s_etat_processus)
Line 3249 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 3666 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 3777 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 3856 evaluation(struct_processus *s_etat_proc	Line 4009 evaluation(struct_processus *s_etat_proc
.objet)).fonction;	.objet)).fonction;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 4005 evaluation(struct_processus *s_etat_proc	Line 4158 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 4122 evaluation(struct_processus *s_etat_proc	Line 4275 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 4208 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 4247 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 4289 evaluation(struct_processus *s_etat_proc	Line 4441 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 4412 evaluation(struct_processus *s_etat_proc	Line 4564 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 4529 evaluation(struct_processus *s_etat_proc	Line 4681 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 4624 evaluation(struct_processus *s_etat_proc	Line 4776 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// On ne détruit pas les variables pour les inclure	// On ne dÃ©truit pas les variables pour les inclure
// dans le fichier rpl-core.	// dans le fichier rpl-core.

(*s_etat_processus).gel_liste_variables = d_vrai;	(*s_etat_processus).gel_liste_variables = d_vrai;
Line 4662 evaluation(struct_processus *s_etat_proc	Line 4814 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 4785 evaluation(struct_processus *s_etat_proc	Line 4937 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 4902 evaluation(struct_processus *s_etat_proc	Line 5054 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 4999 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 5027 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 5062 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 5106 evaluation(struct_processus *s_etat_proc	Line 5262 evaluation(struct_processus *s_etat_proc
.objet)).fonction;	.objet)).fonction;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 5255 evaluation(struct_processus *s_etat_proc	Line 5411 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 5372 evaluation(struct_processus *s_etat_proc	Line 5528 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 5458 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)
{	{
/*	/*
* La fin de l'expression est atteinte,	* La fin de l'expression est atteinte,
* le séquenceur reprend la main.	* le sÃ©quenceur reprend la main.
*/	*/

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
Line 5502 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 5539 evaluation(struct_processus *s_etat_proc	Line 5694 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 5662 evaluation(struct_processus *s_etat_proc	Line 5817 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 5779 evaluation(struct_processus *s_etat_proc	Line 5934 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 5874 evaluation(struct_processus *s_etat_proc	Line 6029 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// On ne détruit pas les variables pour les inclure	// On ne dÃ©truit pas les variables pour les inclure
// dans le fichier rpl-core.	// dans le fichier rpl-core.

(*s_etat_processus).gel_liste_variables = d_vrai;	(*s_etat_processus).gel_liste_variables = d_vrai;
Line 5912 evaluation(struct_processus *s_etat_proc	Line 6067 evaluation(struct_processus *s_etat_proc
= d_es;	= d_es;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 6035 evaluation(struct_processus *s_etat_proc	Line 6190 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 6152 evaluation(struct_processus *s_etat_proc	Line 6307 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour la	// Traitement spÃ©cifique pour la
// fin d'une section critique	// fin d'une section critique

if ((*s_etat_processus)	if ((*s_etat_processus)
Line 6248 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 6327 evaluation(struct_processus *s_etat_proc	Line 6483 evaluation(struct_processus *s_etat_proc
if (((s_etat_processus)	if (((s_etat_processus)
.pointeur_variable_courante).objet == NULL)	.pointeur_variable_courante).objet == NULL)
{	{
// Variable partagée	// Variable partagÃ©e

presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

Line 6418 evaluation(struct_processus *s_etat_proc	Line 6574 evaluation(struct_processus *s_etat_proc
if ((((struct_nom ) ((l_element_courant).donnee)	if ((((struct_nom ) ((l_element_courant).donnee)
.objet)).symbole == d_vrai)	.objet)).symbole == d_vrai)
{	{
// L'objet apparaît comme un symbole dans	// L'objet apparaÃ®t comme un symbole dans
// l'expression en cours d'évaluation. On se	// l'expression en cours d'Ã©valuation. On se
// contente de l'empiler.	// contente de l'empiler.

if ((s_sous_objet = copie_objet(s_etat_processus,	if ((s_sous_objet = copie_objet(s_etat_processus,
Line 6731 evaluation(struct_processus *s_etat_proc	Line 6887 evaluation(struct_processus *s_etat_proc
// Reprise sur erreur.	// Reprise sur erreur.

//==============================================================================	//==============================================================================
// Réindentation	// RÃ©indentation
//==============================================================================	//==============================================================================

drapeau_then = d_faux;	drapeau_then = d_faux;
Line 6774 evaluation(struct_processus *s_etat_proc	Line 6930 evaluation(struct_processus *s_etat_proc
.objet)).fonction;	.objet)).fonction;

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

if (TEST(instruction_if) \|\|	if (TEST(instruction_if) \|\|
Line 6898 evaluation(struct_processus *s_etat_proc	Line 7054 evaluation(struct_processus *s_etat_proc
.type_cloture != 'L'))	.type_cloture != 'L'))
{	{
/*	/*
* Libération des compteurs	* LibÃ©ration des compteurs
* de boucle	* de boucle
*/	*/

Line 6990 evaluation(struct_processus *s_etat_proc	Line 7146 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Traitement spécifique pour	// Traitement spÃ©cifique pour
// la fin d'une section	// la fin d'une section
// critique	// critique

Line 7071 evaluation(struct_processus *s_etat_proc	Line 7227 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

//==============================================================================	//==============================================================================
// Fin de la réindentation	// Fin de la rÃ©indentation
//==============================================================================	//==============================================================================
}	}
}	}
Line 7169 evaluation(struct_processus *s_etat_proc	Line 7325 evaluation(struct_processus *s_etat_proc
}	}

/*	/*
* Vérification du drapeau symbole pour	* VÃ©rification du drapeau symbole pour
* savoir si l'on met dans la pile le nom	* savoir si l'on met dans la pile le nom
* ou le contenu de la variable.	* ou le contenu de la variable.
*/	*/
Line 7186 evaluation(struct_processus *s_etat_proc	Line 7342 evaluation(struct_processus *s_etat_proc
.pointeur_variable_courante).objet	.pointeur_variable_courante).objet
== NULL)	== NULL)
{	{
// Variable partagée	// Variable partagÃ©e

if (recherche_variable_partagee(	if (recherche_variable_partagee(
s_etat_processus,	s_etat_processus,
Line 7243 evaluation(struct_processus *s_etat_proc	Line 7399 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
// Variable privée	// Variable privÃ©e

liberation(s_etat_processus,	liberation(s_etat_processus,
s_objet_elementaire);	s_objet_elementaire);
Line 7327 evaluation(struct_processus *s_etat_proc	Line 7483 evaluation(struct_processus *s_etat_proc
((*s_etat_processus).erreur_execution != d_ex) \|\|	((*s_etat_processus).erreur_execution != d_ex) \|\|
((*s_etat_processus).exception != d_ep))	((*s_etat_processus).exception != d_ep))
{	{
// Il est anormal de récupérer ici une erreur	// Il est anormal de rÃ©cupÃ©rer ici une erreur
// d'exécution puisqu'on empile une constante	// d'exÃ©cution puisqu'on empile une constante
// symbolique.	// symbolique.

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
Line 7425 evaluation(struct_processus *s_etat_proc	Line 7581 evaluation(struct_processus *s_etat_proc
if (niveau_initial < (*s_etat_processus).niveau_courant)	if (niveau_initial < (*s_etat_processus).niveau_courant)
{	{
/*	/*
* Retrait des variables dans le cas où l'évaluation de	* Retrait des variables dans le cas oÃ¹ l'Ã©valuation de
* l'expression a été interrompue	* l'expression a Ã©tÃ© interrompue
*/	*/

(*s_etat_processus).niveau_courant = niveau_initial;	(*s_etat_processus).niveau_courant = niveau_initial;
Line 7447 evaluation(struct_processus *s_etat_proc	Line 7603 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_locales(s_etat_processus) == d_erreur)	if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
Line 7465 evaluation(struct_processus *s_etat_proc	Line 7621 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 (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)	if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
Line 7484 evaluation(struct_processus *s_etat_proc	Line 7640 evaluation(struct_processus *s_etat_proc

if ((*s_etat_processus).var_volatile_requete_arret != 0)	if ((*s_etat_processus).var_volatile_requete_arret != 0)
{	{
// Restauration de la pile système	// Restauration de la pile systÃ¨me

while(pile_systeme_originelle !=	while(pile_systeme_originelle !=
(*s_etat_processus).l_base_pile_systeme)	(*s_etat_processus).l_base_pile_systeme)
Line 7495 evaluation(struct_processus *s_etat_proc	Line 7651 evaluation(struct_processus *s_etat_proc

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
{	{
// Ajout du membre évalué lors de la première passe	// Ajout du membre Ã©valuÃ© lors de la premiÃ¨re passe

if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
s_objet_evalue) == d_erreur)	s_objet_evalue) == d_erreur)
Line 7541 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.84
changed lines
	Added in v.1.103