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.74 and 1.106

version 1.74, 2013/03/06 10:05:09	version 1.106, 2017/07/17 21:38:07
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.27
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2017 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 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 niveau_initial;
unsigned long nombre_termes;
unsigned long registre_hauteur_pile_operationnelle;
unsigned long registre_position_courante;

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

Line 177 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 237 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 291 evaluation(struct_processus *s_etat_proc	Line 290 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 ) ((((*s_etat_processus)	(((integer8 ) ((((*s_etat_processus)
.pointeur_variable_courante).objet).objet)));	.pointeur_variable_courante).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);
}	}
Line 411 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;

// ICI
//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 575 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 637 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 650 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 714 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
*/	*/

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

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 739 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 766 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 804 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 884 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 1033 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 1150 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 1276 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 1399 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 1516 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 1615 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 1653 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 1784 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 1901 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 1998 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 2023 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 2209 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 2318 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 2338 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 2628 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 2936 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 3100 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 3257 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 3408 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 3675 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 3786 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 3865 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 4014 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 4131 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 4217 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 4256 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 4298 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 4421 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 4538 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 4633 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 4671 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 4794 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 4911 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 5008 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 5036 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 5071 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 5115 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 5264 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 5381 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 5467 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 5511 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 5548 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 5671 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 5788 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 5883 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 5921 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 6044 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 6161 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 6257 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 6336 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 6427 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 6497 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 6505 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 6730 evaluation(struct_processus *s_etat_proc	Line 6877 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)
	.type_cloture = 'L';
	}
	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)
	.clause = 'X';
	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 6825 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 6842 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 6899 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 6983 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 7081 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 7103 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 7121 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 7140 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 7151 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 7170 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 7185 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 7195 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 7205 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.74
changed lines
	Added in v.1.106