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.9 and 1.36

version 1.9, 2010/04/07 13:33:22	version 1.36, 2011/04/21 16:00:54
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.13	RPL/2 (R) version 4.1.0.prerelease.0
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


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

#define TEST(instruction) (fonction == instruction)	#define TEST(instruction) (fonction == instruction)
#define vers_niveau_inferieur instruction_vers_niveau_inferieur	#define vers_niveau_inferieur instruction_vers_niveau_inferieur
Line 76 evaluation(struct_processus *s_etat_proc	Line 76 evaluation(struct_processus *s_etat_proc
struct_objet *s_sous_objet;	struct_objet *s_sous_objet;
struct_objet *s_copie_variable_partagee;	struct_objet *s_copie_variable_partagee;

struct_variable *registre_variables;

unsigned char autorisation_empilement_programme;	unsigned char autorisation_empilement_programme;
unsigned char *instruction_courante;	unsigned char *instruction_courante;
unsigned char *message;	unsigned char *message;
Line 97 evaluation(struct_processus *s_etat_proc	Line 95 evaluation(struct_processus *s_etat_proc
unsigned long k;	unsigned long k;
unsigned long l;	unsigned long l;
unsigned long n;	unsigned long n;
unsigned long m;
unsigned long niveau_initial;	unsigned long niveau_initial;
unsigned long nombre_termes;	unsigned long nombre_termes;
unsigned long registre_hauteur_pile_operationnelle;	unsigned long registre_hauteur_pile_operationnelle;
Line 143 evaluation(struct_processus *s_etat_proc	Line 140 evaluation(struct_processus *s_etat_proc
if (recherche_variable(s_etat_processus, (((struct_nom )	if (recherche_variable(s_etat_processus, (((struct_nom )
(*s_objet_tampon).objet)).nom) == d_faux)	(*s_objet_tampon).objet)).nom) == d_faux)
{	{
	(*s_etat_processus).erreur_execution = d_ex;

if ((*s_etat_processus).autorisation_nom_implicite == 'N')	if ((*s_etat_processus).autorisation_nom_implicite == 'N')
{	{
if ((((struct_nom ) (*s_objet_tampon).objet)).symbole ==	if ((((struct_nom ) (*s_objet_tampon).objet)).symbole ==
d_faux)	d_faux)
{	{
	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
	if (empilement_pile_last(s_etat_processus, 0)
	== d_erreur)
	{
	return(d_erreur);
	}
	}

	erreur_evaluation = d_erreur;
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_manque_argument;	d_ex_nom_implicite;
return(d_erreur);
	if (type_evaluation == 'I')
	{
	(*s_etat_processus).derniere_erreur_evaluation =
	(*s_etat_processus).erreur_execution;
	}
}	}
}	}

Line 161 evaluation(struct_processus *s_etat_proc	Line 175 evaluation(struct_processus *s_etat_proc
{	{
if ((*s_etat_processus).traitement_symbolique == 'N')	if ((*s_etat_processus).traitement_symbolique == 'N')
{	{
if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]
.objet == NULL)	.objet == NULL)
{	{
// Variable partagée	// Variable partagée
Line 178 evaluation(struct_processus *s_etat_proc	Line 191 evaluation(struct_processus *s_etat_proc
presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).nom,
.position_variable_courante]).nom,	((s_etat_processus)
((*s_etat_processus).s_liste_variables	.pointeur_variable_courante)
[(*s_etat_processus)
.position_variable_courante])
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') == d_vrai)
{	{
presence_variable = d_vrai;	presence_variable = d_vrai;
Line 252 evaluation(struct_processus *s_etat_proc	Line 263 evaluation(struct_processus *s_etat_proc

presence_variable = d_vrai;	presence_variable = d_vrai;

if ((((s_etat_processus).s_liste_variables	if ((((*s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]	.objet).type == ADR)
.objet)).type == ADR)
{	{
presence_fonction = d_vrai;	presence_fonction = d_vrai;
}	}
Line 305 evaluation(struct_processus *s_etat_proc	Line 315 evaluation(struct_processus *s_etat_proc
{	{
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((unsigned long )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.objet).objet)));
.position_variable_courante]
.objet)).objet)));
}	}
else	else
{	{
Line 329 evaluation(struct_processus *s_etat_proc	Line 337 evaluation(struct_processus *s_etat_proc
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus,	profilage(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]
.nom);	.nom);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
Line 382 evaluation(struct_processus *s_etat_proc	Line 389 evaluation(struct_processus *s_etat_proc
registre_evaluation_expression_compilee =	registre_evaluation_expression_compilee =
(*s_etat_processus).evaluation_expression_compilee;	(*s_etat_processus).evaluation_expression_compilee;

if (((s_etat_processus).s_liste_variables[(s_etat_processus)	if ((((s_etat_processus).pointeur_variable_courante).origine
.position_variable_courante].origine == 'E') &&	== 'E') && (((s_etat_processus)
((*s_etat_processus).s_liste_variables	.pointeur_variable_courante).niveau == 0))
[(*s_etat_processus).position_variable_courante].niveau
== 0))
{	{
(*s_etat_processus).evaluation_expression_compilee = 'Y';	(*s_etat_processus).evaluation_expression_compilee = 'Y';
}	}
Line 398 evaluation(struct_processus *s_etat_proc	Line 403 evaluation(struct_processus *s_etat_proc
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus,	profilage(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]
.nom);	.nom);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
Line 419 evaluation(struct_processus *s_etat_proc	Line 423 evaluation(struct_processus *s_etat_proc
}	}
}	}

	autorisation_empilement_programme = (*s_etat_processus)
	.autorisation_empilement_programme;

	empilement_pile_systeme(s_etat_processus);

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

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

	((s_etat_processus).l_base_pile_systeme)
	.retour_definition = 'Y';
	((s_etat_processus).l_base_pile_systeme)
	.origine_routine_evaluation = 'Y';

	(*s_etat_processus).mode_execution_programme = 'Y';
	(*s_etat_processus).autorisation_empilement_programme = 'N';

	((s_etat_processus).l_base_pile_systeme)
	.niveau_courant = (*s_etat_processus)
	.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)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet,
.position_variable_courante].objet,
type_evaluation) == d_erreur)	type_evaluation) == d_erreur)
{	{
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 471 evaluation(struct_processus *s_etat_proc	Line 505 evaluation(struct_processus *s_etat_proc
profilage(s_etat_processus, NULL);	profilage(s_etat_processus, NULL);
}	}

	depilement_pile_systeme(s_etat_processus);
	depilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return(d_erreur);
	}

(*s_etat_processus).evaluation_expression_compilee =	(*s_etat_processus).evaluation_expression_compilee =
registre_evaluation_expression_compilee;	registre_evaluation_expression_compilee;
	(*s_etat_processus).autorisation_empilement_programme =
	autorisation_empilement_programme;
}	}
else	else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
{	{
if ((s_objet_tampon = copie_objet(s_etat_processus,	if ((s_objet_tampon = copie_objet(s_etat_processus,
s_objet, 'P')) == NULL)	s_objet, 'Q')) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 495 evaluation(struct_processus *s_etat_proc	Line 539 evaluation(struct_processus *s_etat_proc
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
}	}

if ((*s_etat_processus).erreur_execution ==
d_ex_variable_non_definie)
{
(*s_etat_processus).erreur_execution = d_ex;
}
}	}
}	}
else	else
Line 719 evaluation(struct_processus *s_etat_proc	Line 757 evaluation(struct_processus *s_etat_proc
registre_retour_definition = ((s_etat_processus).l_base_pile_systeme)	registre_retour_definition = ((s_etat_processus).l_base_pile_systeme)
.retour_definition;	.retour_definition;
((s_etat_processus).l_base_pile_systeme).retour_definition = 'N';	((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)
Line 818 evaluation(struct_processus *s_etat_proc	Line 858 evaluation(struct_processus *s_etat_proc

free(message);	free(message);

while(((s_etat_processus).l_base_pile_systeme)	drapeau_then = d_faux;
.clause != 'R')
	while(drapeau_then == d_faux)
{	{
l_registre_atome = l_element_courant;	l_registre_atome = l_element_courant;
l_element_courant =	l_element_courant =
Line 981 evaluation(struct_processus *s_etat_proc	Line 1022 evaluation(struct_processus *s_etat_proc
}	}
}	}
}	}
	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 =	(*s_etat_processus).instruction_courante =
instruction_courante;	instruction_courante;
drapeau_then = d_faux;

do
{
l_registre_atome = l_element_courant;

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;
(*s_etat_processus).instruction_courante =
instruction_courante;
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;
fonction = (((struct_fonction )
((l_element_courant).donnee)
.objet)).fonction;
(*s_etat_processus).instruction_courante =
instruction_courante;

drapeau_then = TEST(instruction_then)
? d_vrai : d_faux;
}

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

(*s_etat_processus).expression_courante =
l_registre_atome;

((s_etat_processus).l_base_pile_systeme)
.clause = 'X';
instruction_then(s_etat_processus);

(*s_etat_processus).exception = d_ep;	(*s_etat_processus).exception = d_ep;
(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;
Line 1146 evaluation(struct_processus *s_etat_proc	Line 1149 evaluation(struct_processus *s_etat_proc
{	{
depilement_pile_systeme(	depilement_pile_systeme(
s_etat_processus);	s_etat_processus);
	}

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

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

	(*s_etat_processus)
	.instruction_courante =
	instruction_courante;
	return(d_erreur);
}	}
}	}
}	}
Line 1294 evaluation(struct_processus *s_etat_proc	Line 1297 evaluation(struct_processus *s_etat_proc
instruction_courante;	instruction_courante;
return(d_erreur);	return(d_erreur);
}	}

	if (((s_etat_processus)
	.l_base_pile_systeme)
	.retour_definition
	== 'Y')
	{
	break;
	}
}	}
else	else
{	{
Line 1649 evaluation(struct_processus *s_etat_proc	Line 1660 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante).objet
[(*s_etat_processus).position_variable_courante]	== NULL)
.objet == NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)	if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 1661 evaluation(struct_processus *s_etat_proc	Line 1671 evaluation(struct_processus *s_etat_proc
}	}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).nom,
.position_variable_courante]).nom,	((s_etat_processus)
((*s_etat_processus).s_liste_variables	.pointeur_variable_courante).variable_partagee,
[(*s_etat_processus)	'E') == d_vrai)
.position_variable_courante])
.variable_partagee, 'E') == d_vrai)
{	{
// Une variable partagée existe.	// Une variable partagée existe.

presence_variable_partagee = d_vrai;	presence_variable_partagee = d_vrai;

(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.objet = ((s_etat_processus)
.position_variable_courante].objet =
((s_etat_processus)
.s_liste_variables_partagees).table	.s_liste_variables_partagees).table
[((s_etat_processus)	[((s_etat_processus)
.s_liste_variables_partagees)	.s_liste_variables_partagees)
Line 1703 evaluation(struct_processus *s_etat_proc	Line 1709 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).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante])
.objet == NULL)	.objet == NULL)
{	{
// La variable partagée n'existe plus.	// La variable partagée n'existe plus.
Line 1717 evaluation(struct_processus *s_etat_proc	Line 1722 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet =
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
Line 1736 evaluation(struct_processus *s_etat_proc	Line 1740 evaluation(struct_processus *s_etat_proc
return(d_erreur);;	return(d_erreur);;
}	}
}	}
else if (((((((s_etat_processus).s_liste_variables	else if (((((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == VIN) \|\|
.objet)).type == VIN) \|\|	(((((*s_etat_processus)
(((((s_etat_processus).s_liste_variables	.pointeur_variable_courante).objet)).type == VRL) \|\|
[(*s_etat_processus).position_variable_courante])	(((((*s_etat_processus)
.objet)).type == VRL) \|\|	.pointeur_variable_courante).objet)).type == VCX))
(((((s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante])
.objet)).type == VCX))
&& ((((struct_fonction ) ((l_element_courant)	&& ((((struct_fonction ) ((l_element_courant)
.donnee).objet)).nombre_arguments == 1))	.donnee).objet)).nombre_arguments == 1))
{	{
Line 1755 evaluation(struct_processus *s_etat_proc	Line 1756 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet =
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
Line 1783 evaluation(struct_processus *s_etat_proc	Line 1783 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

if ((*s_objet_indice_i).type == INT)	if ((*s_objet_indice_i).type != INT)
{	{
liberation(s_etat_processus, s_objet_indice_i);	liberation(s_etat_processus, s_objet_indice_i);
free(s_objet_elementaire);	free(s_objet_elementaire);

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet =
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
Line 1823 evaluation(struct_processus *s_etat_proc	Line 1822 evaluation(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet_indice_i);	liberation(s_etat_processus, s_objet_indice_i);

if ((i < 1) \|\| (i > (integer8) (((struct_vecteur )	if ((i < 1) \|\| (i > (integer8) (((struct_vecteur )
((((s_etat_processus)	((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).objet))
.position_variable_courante]).objet)).objet))
.taille))	.taille))
{	{
free(s_objet_elementaire);	free(s_objet_elementaire);

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet =
NULL;	NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
Line 1860 evaluation(struct_processus *s_etat_proc	Line 1857 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

if (((((s_etat_processus).s_liste_variables	if (((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet)).type
.position_variable_courante]).objet)).type
== VIN)	== VIN)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1876 evaluation(struct_processus *s_etat_proc	Line 1872 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 1901 evaluation(struct_processus *s_etat_proc	Line 1896 evaluation(struct_processus *s_etat_proc
(*s_objet_elementaire).type = INT;	(*s_objet_elementaire).type = INT;
(((integer8 ) (*s_objet_elementaire).objet)) =	(((integer8 ) (*s_objet_elementaire).objet)) =
((integer8 ) (((struct_vecteur *)	((integer8 ) (((struct_vecteur *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1];	.objet)).tableau)[i - 1];
}	}
else if (((((s_etat_processus)	else if (((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).type
.position_variable_courante]).objet)).type
== VRL)	== VRL)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1916 evaluation(struct_processus *s_etat_proc	Line 1909 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 1947 evaluation(struct_processus *s_etat_proc	Line 1939 evaluation(struct_processus *s_etat_proc
(*s_objet_elementaire).type = REL;	(*s_objet_elementaire).type = REL;
(((real8 ) (*s_objet_elementaire).objet)) =	(((real8 ) (*s_objet_elementaire).objet)) =
((real8 ) (((struct_vecteur *)	((real8 ) (((struct_vecteur *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1];	.objet)).tableau)[i - 1];
}	}
else if (((((s_etat_processus)	else if (((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).type
.position_variable_courante]).objet)).type
== VCX)	== VCX)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1962 evaluation(struct_processus *s_etat_proc	Line 1952 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 1994 evaluation(struct_processus *s_etat_proc	Line 1983 evaluation(struct_processus *s_etat_proc
(((struct_complexe16 ) (*s_objet_elementaire)	(((struct_complexe16 ) (*s_objet_elementaire)
.objet)).partie_reelle =	.objet)).partie_reelle =
((struct_complexe16 ) (((struct_vecteur *)	((struct_complexe16 ) (((struct_vecteur *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))	.objet)).tableau)[i - 1].partie_reelle;
.objet)).tableau)[i - 1]
.partie_reelle;
(((struct_complexe16 ) (*s_objet_elementaire)	(((struct_complexe16 ) (*s_objet_elementaire)
.objet)).partie_imaginaire =	.objet)).partie_imaginaire =
((struct_complexe16 ) (((struct_vecteur *)	((struct_complexe16 ) (((struct_vecteur *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))	.objet)).tableau)[i - 1].partie_imaginaire;
.objet)).tableau)[i - 1]
.partie_imaginaire;
}	}
}	}

Line 2014 evaluation(struct_processus *s_etat_proc	Line 1999 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).s_liste_variables	else if (((((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == MIN) \|\|
.objet)).type == MIN) \|\|	(((((*s_etat_processus)
(((((s_etat_processus).s_liste_variables	.pointeur_variable_courante).objet)).type == MRL) \|\|
[(*s_etat_processus).position_variable_courante])	(((((*s_etat_processus)
.objet)).type == MRL) \|\|	.pointeur_variable_courante).objet)).type == MCX))
(((((s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante])
.objet)).type == MCX))
&& ((((struct_fonction ) ((l_element_courant)	&& ((((struct_fonction ) ((l_element_courant)
.donnee).objet)).nombre_arguments == 2))	.donnee).objet)).nombre_arguments == 2))
{	{
Line 2033 evaluation(struct_processus *s_etat_proc	Line 2015 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2070 evaluation(struct_processus *s_etat_proc	Line 2051 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2108 evaluation(struct_processus *s_etat_proc	Line 2088 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2144 evaluation(struct_processus *s_etat_proc	Line 2123 evaluation(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet_indice_j);	liberation(s_etat_processus, s_objet_indice_j);

if ((i < 1) \|\| (i > (integer8) (((struct_matrice )	if ((i < 1) \|\| (i > (integer8) (((struct_matrice )
((((s_etat_processus)	((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).objet))
.position_variable_courante]).objet)).objet))
.nombre_lignes) \|\| (j < 1) \|\| (j > (integer8)	.nombre_lignes) \|\| (j < 1) \|\| (j > (integer8)
(((struct_matrice ) ((((s_etat_processus)	(((struct_matrice ) ((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).objet))
.position_variable_courante]).objet)).objet))
.nombre_colonnes))	.nombre_colonnes))
{	{
liberation(s_etat_processus, s_objet_indice_i);
liberation(s_etat_processus, s_objet_indice_j);
free(s_objet_elementaire);	free(s_objet_elementaire);

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2188 evaluation(struct_processus *s_etat_proc	Line 2162 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

if (((((s_etat_processus).s_liste_variables	if (((((*s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.objet)).type == MIN)
.position_variable_courante]).objet)).type
== MIN)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
integer8))) == NULL)	integer8))) == NULL)
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2229 evaluation(struct_processus *s_etat_proc	Line 2200 evaluation(struct_processus *s_etat_proc
(*s_objet_elementaire).type = INT;	(*s_objet_elementaire).type = INT;
(((integer8 ) (*s_objet_elementaire).objet)) =	(((integer8 ) (*s_objet_elementaire).objet)) =
((integer8 *) (((struct_matrice *)	((integer8 *) (((struct_matrice *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1][j - 1];	.objet)).tableau)[i - 1][j - 1];
}	}
else if (((((s_etat_processus)	else if (((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).type
.position_variable_courante]).objet)).type
== MRL)	== MRL)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 2244 evaluation(struct_processus *s_etat_proc	Line 2213 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2275 evaluation(struct_processus *s_etat_proc	Line 2243 evaluation(struct_processus *s_etat_proc
(*s_objet_elementaire).type = REL;	(*s_objet_elementaire).type = REL;
(((real8 ) (*s_objet_elementaire).objet)) =	(((real8 ) (*s_objet_elementaire).objet)) =
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1][j - 1];	.objet)).tableau)[i - 1][j - 1];
}	}
else if (((((s_etat_processus)	else if (((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).type
.position_variable_courante]).objet)).type
== MCX)	== MCX)
{	{
if (((*s_objet_elementaire).objet = malloc(sizeof(	if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 2290 evaluation(struct_processus *s_etat_proc	Line 2256 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2323 evaluation(struct_processus *s_etat_proc	Line 2288 evaluation(struct_processus *s_etat_proc
.objet)).partie_reelle =	.objet)).partie_reelle =
((struct_complexe16 **)	((struct_complexe16 **)
(((struct_matrice )	(((struct_matrice )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1][j - 1]	.objet)).tableau)[i - 1][j - 1]
.partie_reelle;	.partie_reelle;
(((struct_complexe16 ) (*s_objet_elementaire)	(((struct_complexe16 ) (*s_objet_elementaire)
.objet)).partie_imaginaire =	.objet)).partie_imaginaire =
((struct_complexe16 **)	((struct_complexe16 **)
(((struct_matrice )	(((struct_matrice )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet))
.position_variable_courante]).objet))
.objet)).tableau)[i - 1][j - 1]	.objet)).tableau)[i - 1][j - 1]
.partie_imaginaire;	.partie_imaginaire;
}	}
Line 2344 evaluation(struct_processus *s_etat_proc	Line 2307 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).s_liste_variables	else if ((((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == LST) &&
.objet)).type == LST) &&
((((struct_fonction ) ((l_element_courant)	((((struct_fonction ) ((l_element_courant)
.donnee).objet)).nombre_arguments == 1))	.donnee).objet)).nombre_arguments == 1))
{	{
Line 2357 evaluation(struct_processus *s_etat_proc	Line 2319 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2393 evaluation(struct_processus *s_etat_proc	Line 2354 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2426 evaluation(struct_processus *s_etat_proc	Line 2386 evaluation(struct_processus *s_etat_proc

liberation(s_etat_processus, s_objet_indice_i);	liberation(s_etat_processus, s_objet_indice_i);

l_sous_element_courant = ((((s_etat_processus)	l_sous_element_courant = ((((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)).objet;
.position_variable_courante]).objet)).objet;
j = 0;	j = 0;

while(l_sous_element_courant != NULL)	while(l_sous_element_courant != NULL)
Line 2448 evaluation(struct_processus *s_etat_proc	Line 2407 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2485 evaluation(struct_processus *s_etat_proc	Line 2443 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2517 evaluation(struct_processus *s_etat_proc	Line 2474 evaluation(struct_processus *s_etat_proc
* Recherche de l'élément idoine dans la table	* Recherche de l'élément idoine dans la table
*/	*/

else if ((((((s_etat_processus).s_liste_variables	else if ((((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == TBL) &&
.objet)).type == TAB) &&
((((struct_fonction ) ((l_element_courant)	((((struct_fonction ) ((l_element_courant)
.donnee).objet)).nombre_arguments == 1))	.donnee).objet)).nombre_arguments == 1))
{	{
Line 2530 evaluation(struct_processus *s_etat_proc	Line 2486 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2566 evaluation(struct_processus *s_etat_proc	Line 2521 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2600 evaluation(struct_processus *s_etat_proc	Line 2554 evaluation(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet_indice_i);	liberation(s_etat_processus, s_objet_indice_i);

if ((i < 1) \|\| (i > (integer8) (((struct_tableau )	if ((i < 1) \|\| (i > (integer8) (((struct_tableau )
(((s_etat_processus).s_liste_variables	(((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet)
.position_variable_courante]).objet)
.objet)).nombre_elements))	.objet)).nombre_elements))
{	{
free(s_objet_elementaire);	free(s_objet_elementaire);

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2642 evaluation(struct_processus *s_etat_proc	Line 2594 evaluation(struct_processus *s_etat_proc

if ((s_objet_elementaire =	if ((s_objet_elementaire =
copie_objet(s_etat_processus,	copie_objet(s_etat_processus,
(((struct_tableau ) (((s_etat_processus)	(((struct_tableau ) (((*s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet)
.position_variable_courante]).objet)
.objet)).elements[i - 1], 'P')) == NULL)	.objet)).elements[i - 1], 'P')) == NULL)
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2676 evaluation(struct_processus *s_etat_proc	Line 2626 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}
}	}
else if ((((((s_etat_processus).s_liste_variables	else if ((((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == ALG) \|\|
.objet)).type == ALG) \|\|	(((((*s_etat_processus)
(((((s_etat_processus).s_liste_variables	.pointeur_variable_courante).objet)).type == RPN))
[(*s_etat_processus).position_variable_courante])
.objet)).type == RPN))
{	{
registre_evaluation_expression_compilee =	registre_evaluation_expression_compilee =
(*s_etat_processus)	(*s_etat_processus)
.evaluation_expression_compilee;	.evaluation_expression_compilee;

if (((*s_etat_processus).s_liste_variables	if ((((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.origine == 'E') && (((s_etat_processus)
.position_variable_courante].origine == 'E') &&	.pointeur_variable_courante).niveau == 0))
((*s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante]
.niveau == 0))
{	{
(*s_etat_processus).evaluation_expression_compilee =	(*s_etat_processus).evaluation_expression_compilee =
'Y';	'Y';
Line 2703 evaluation(struct_processus *s_etat_proc	Line 2648 evaluation(struct_processus *s_etat_proc
'N';	'N';
}	}

if (evaluation(s_etat_processus, (*s_etat_processus)	if (evaluation(s_etat_processus, ((s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet,
.position_variable_courante].objet,
type_evaluation) == d_erreur)	type_evaluation) == d_erreur)
{	{
(*s_etat_processus).evaluation_expression_compilee =	(*s_etat_processus).evaluation_expression_compilee =
Line 2713 evaluation(struct_processus *s_etat_proc	Line 2657 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2751 evaluation(struct_processus *s_etat_proc	Line 2694 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2780 evaluation(struct_processus *s_etat_proc	Line 2722 evaluation(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}
}	}
else if (((((s_etat_processus).s_liste_variables	else if (((((*s_etat_processus)
[(*s_etat_processus).position_variable_courante])	.pointeur_variable_courante).objet)).type == ADR)
.objet)).type == ADR)
{	{
autorisation_empilement_programme = (*s_etat_processus)	autorisation_empilement_programme = (*s_etat_processus)
.autorisation_empilement_programme;	.autorisation_empilement_programme;
Line 2795 evaluation(struct_processus *s_etat_proc	Line 2736 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2835 evaluation(struct_processus *s_etat_proc	Line 2775 evaluation(struct_processus *s_etat_proc

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((unsigned long )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet).objet)));
.position_variable_courante]
.objet)).objet)));

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus,	profilage(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).nom);
.position_variable_courante].nom);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(	if (pthread_mutex_unlock(
&(((s_etat_processus)	&(((s_etat_processus)
Line 2885 evaluation(struct_processus *s_etat_proc	Line 2821 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees)	.s_liste_variables_partagees)
Line 2923 evaluation(struct_processus *s_etat_proc	Line 2858 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees)	.s_liste_variables_partagees)
Line 2959 evaluation(struct_processus *s_etat_proc	Line 2893 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.s_liste_variables_partagees).mutex))
Line 2991 evaluation(struct_processus *s_etat_proc	Line 2924 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees) .mutex)) != 0)	.s_liste_variables_partagees) .mutex)) != 0)
Line 3024 evaluation(struct_processus *s_etat_proc	Line 2956 evaluation(struct_processus *s_etat_proc
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet =
.position_variable_courante].objet	NULL;
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 3049 evaluation(struct_processus *s_etat_proc	Line 2980 evaluation(struct_processus *s_etat_proc

if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
{	{
(*s_etat_processus).s_liste_variables	((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet = NULL;
.position_variable_courante].objet
= NULL;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 4013 evaluation(struct_processus *s_etat_proc	Line 3942 evaluation(struct_processus *s_etat_proc
{	{
/*	/*
* La fin de l'expression est atteinte,	* La fin de l'expression est atteinte,
* le sequenceur reprend la main.	* le séquenceur reprend la main.
*/	*/

if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
Line 4392 evaluation(struct_processus *s_etat_proc	Line 4321 evaluation(struct_processus *s_etat_proc
if (recherche_variable(s_etat_processus, (((struct_nom )	if (recherche_variable(s_etat_processus, (((struct_nom )
(*s_objet_elementaire).objet)).nom) == d_faux)	(*s_objet_elementaire).objet)).nom) == d_faux)
{	{
	(*s_etat_processus).erreur_systeme = d_es;
	presence_variable = d_faux;

if ((*s_etat_processus).autorisation_nom_implicite	if ((*s_etat_processus).autorisation_nom_implicite
== 'N')	== 'N')
{	{
if ((((struct_nom ) (*s_objet_elementaire).objet))	if ((((struct_nom ) (*s_objet_elementaire).objet))
.symbole == d_faux)	.symbole == d_faux)
{	{
(*s_etat_processus).erreur_systeme =	if (test_cfsf(s_etat_processus, 31) == d_vrai)
d_es_nom_implicite;	{
return(d_erreur);	if (empilement_pile_last(s_etat_processus,
	0) == d_erreur)
	{
	return(d_erreur);
	}
	}

	erreur_evaluation = d_erreur;
	(*s_etat_processus).erreur_execution =
	d_ex_nom_implicite;

	if (type_evaluation == 'I')
	{
	(*s_etat_processus)
	.derniere_erreur_evaluation =
	(*s_etat_processus)
	.erreur_execution;
	}
}	}
}	}

(*s_etat_processus).erreur_systeme = d_es;
presence_variable = d_faux;
}	}
else	else
{	{
if ((*s_etat_processus).traitement_symbolique == 'N')	if ((*s_etat_processus).traitement_symbolique == 'N')
{	{
if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet == NULL)
.position_variable_courante].objet == NULL)
{	{
// Variable partagée	// Variable partagée

Line 4429 evaluation(struct_processus *s_etat_proc	Line 4374 evaluation(struct_processus *s_etat_proc
presence_variable_partagee = d_faux;	presence_variable_partagee = d_faux;

if (recherche_variable_partagee(	if (recherche_variable_partagee(
s_etat_processus,	s_etat_processus, ((s_etat_processus)
((*s_etat_processus).s_liste_variables	.pointeur_variable_courante).nom,
[(*s_etat_processus)	((s_etat_processus)
.position_variable_courante]).nom,	.pointeur_variable_courante)
((*s_etat_processus).s_liste_variables
[(*s_etat_processus)
.position_variable_courante])
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') == d_vrai)
{	{
presence_variable = d_vrai;	presence_variable = d_vrai;
Line 4513 evaluation(struct_processus *s_etat_proc	Line 4455 evaluation(struct_processus *s_etat_proc
{	{
presence_variable = d_vrai;	presence_variable = d_vrai;

if ((((s_etat_processus)	if ((((*s_etat_processus)
.s_liste_variables	.pointeur_variable_courante).objet)
[(*s_etat_processus)	.type == ADR)
.position_variable_courante]
.objet)).type == ADR)
{	{
presence_fonction = d_vrai;	presence_fonction = d_vrai;
}	}
Line 4533 evaluation(struct_processus *s_etat_proc	Line 4473 evaluation(struct_processus *s_etat_proc

if (presence_fonction == d_vrai)	if (presence_fonction == d_vrai)
{	{
autorisation_empilement_programme = (*s_etat_processus)	if ((((struct_nom ) ((l_element_courant).donnee)
.autorisation_empilement_programme;	.objet)).symbole == d_vrai)
registre_position_courante = (*s_etat_processus)
.position_courante;

empilement_pile_systeme(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)
{	{
if (presence_variable_partagee == d_vrai)	// L'objet apparaît comme un symbole dans
	// l'expression en cours d'évaluation. On se
	// contente de l'empiler.

	if ((s_sous_objet = copie_objet(s_etat_processus,
	(*l_element_courant).donnee, 'P')) == NULL)
{	{
liberation(s_etat_processus,	(*s_etat_processus).instruction_courante =
s_copie_variable_partagee);	instruction_courante;

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

if (presence_egalite == d_vrai)	if (empilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	s_sous_objet) == d_erreur)
{	{
liberation(s_etat_processus, s_objet_evalue);	(*s_etat_processus).instruction_courante =
	instruction_courante;
	liberation(s_etat_processus, s_sous_objet);
	return(d_erreur);
}	}

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

((s_etat_processus).l_base_pile_systeme)
.retour_definition = 'Y';
((s_etat_processus).l_base_pile_systeme)
.origine_routine_evaluation = 'Y';

(*s_etat_processus).mode_execution_programme = 'Y';
(*s_etat_processus).autorisation_empilement_programme
= 'N';

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

if (presence_variable_partagee == d_faux)
{
(*s_etat_processus).position_courante =
(((unsigned long )
((((s_etat_processus).s_liste_variables
[(*s_etat_processus)
.position_variable_courante]
.objet)).objet)));
}	}
else	else
{	{
(*s_etat_processus).position_courante =	autorisation_empilement_programme =
(((unsigned long )	(*s_etat_processus)
(*s_copie_variable_partagee).objet));	.autorisation_empilement_programme;
liberation(s_etat_processus,	registre_position_courante = (*s_etat_processus)
s_copie_variable_partagee);	.position_courante;
}

if ((*s_etat_processus).profilage == d_vrai)	empilement_pile_systeme(s_etat_processus);
{
profilage(s_etat_processus,
(*s_etat_processus).s_liste_variables
[(*s_etat_processus)
.position_variable_courante].nom);

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

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

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

registre_evaluation_forcee =	((s_etat_processus).l_base_pile_systeme)
(*s_etat_processus).evaluation_forcee;	.retour_definition = 'Y';
	((s_etat_processus).l_base_pile_systeme)
	.origine_routine_evaluation = 'Y';

if (type_evaluation == 'N')	(*s_etat_processus).mode_execution_programme = 'Y';
{	(*s_etat_processus)
(*s_etat_processus).evaluation_forcee = 'Y';	.autorisation_empilement_programme = 'N';
}

if (sequenceur(s_etat_processus) == d_erreur)	((s_etat_processus).l_base_pile_systeme)
{	.niveau_courant = (*s_etat_processus)
(*s_etat_processus).evaluation_forcee =	.niveau_courant;
registre_evaluation_forcee;

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

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus,
	((s_etat_processus)
	.pointeur_variable_courante).nom);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return(d_erreur);
	}
	}

	registre_evaluation_forcee =
	(*s_etat_processus).evaluation_forcee;

	if (type_evaluation == 'N')
	{
	(*s_etat_processus).evaluation_forcee = 'Y';
	}

	if (sequenceur(s_etat_processus) == d_erreur)
	{
	(*s_etat_processus).evaluation_forcee =
	registre_evaluation_forcee;

	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);
}	}

	(*s_etat_processus).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 =	(*s_etat_processus).mode_execution_programme = 'N';
registre_mode_execution_programme;
return(d_erreur);
}

(*s_etat_processus).evaluation_forcee =	depilement_pile_systeme(s_etat_processus);
registre_evaluation_forcee;
(*s_etat_processus).instruction_courante =
instruction_courante;
(*s_etat_processus).mode_execution_programme = 'N';

depilement_pile_systeme(s_etat_processus);

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

	return(d_erreur);
}	}

return(d_erreur);	(*s_etat_processus).retour_routine_evaluation = 'N';
	(*s_etat_processus).position_courante =
	registre_position_courante;
	(*s_etat_processus)
	.autorisation_empilement_programme =
	autorisation_empilement_programme;
}	}

(*s_etat_processus).retour_routine_evaluation = 'N';
(*s_etat_processus).position_courante =
registre_position_courante;
(*s_etat_processus).autorisation_empilement_programme =
autorisation_empilement_programme;
}	}
else if (((type_evaluation == 'N') \|\| ((((struct_nom )	else if (((type_evaluation == 'N') \|\| ((((struct_nom )
((l_element_courant).donnee).objet)).symbole ==	((l_element_courant).donnee).objet)).symbole ==
Line 4661 evaluation(struct_processus *s_etat_proc	Line 4635 evaluation(struct_processus *s_etat_proc
{	{
if ((s_sous_objet =	if ((s_sous_objet =
copie_objet(s_etat_processus,	copie_objet(s_etat_processus,
(*s_etat_processus)	((s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet,
.position_variable_courante].objet,
'P')) == NULL)	'P')) == NULL)
{	{
if (presence_variable_partagee == d_vrai)	if (presence_variable_partagee == d_vrai)
Line 4732 evaluation(struct_processus *s_etat_proc	Line 4705 evaluation(struct_processus *s_etat_proc
(*s_etat_processus)	(*s_etat_processus)
.evaluation_expression_compilee;	.evaluation_expression_compilee;

if (((*s_etat_processus).s_liste_variables	if ((((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante)
.position_variable_courante].origine == 'E')	.origine == 'E') && (((s_etat_processus)
&& ((*s_etat_processus).s_liste_variables	.pointeur_variable_courante).niveau == 0))
[(*s_etat_processus)
.position_variable_courante].niveau == 0))
{	{
(*s_etat_processus)	(*s_etat_processus)
.evaluation_expression_compilee = 'Y';	.evaluation_expression_compilee = 'Y';
Line 4753 evaluation(struct_processus *s_etat_proc	Line 4724 evaluation(struct_processus *s_etat_proc
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus,	profilage(s_etat_processus,
(*s_etat_processus)	((s_etat_processus)
.s_liste_variables	.pointeur_variable_courante).nom);
[(*s_etat_processus)
.position_variable_courante].nom);

if ((*s_etat_processus).erreur_systeme	if ((*s_etat_processus).erreur_systeme
!= d_es)	!= d_es)
Line 4779 evaluation(struct_processus *s_etat_proc	Line 4748 evaluation(struct_processus *s_etat_proc
empilement_pile_systeme(s_etat_processus);	empilement_pile_systeme(s_etat_processus);

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
(*s_etat_processus)	((s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet,
.position_variable_courante].objet,
type_evaluation) == d_erreur)	type_evaluation) == d_erreur)
{	{
depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant =	.niveau_courant =
	registre_niveau_courant;
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition =	.retour_definition =
registre_retour_definition;	registre_retour_definition;
Line 4818 evaluation(struct_processus *s_etat_proc	Line 4787 evaluation(struct_processus *s_etat_proc

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.niveau_courant =	.niveau_courant =
	registre_niveau_courant;
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition =	.retour_definition =
registre_retour_definition;	registre_retour_definition;
Line 4827 evaluation(struct_processus *s_etat_proc	Line 4797 evaluation(struct_processus *s_etat_proc
if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus,	profilage(s_etat_processus,
(*s_etat_processus)	((s_etat_processus)
.s_liste_variables	.pointeur_variable_courante).nom);
[(*s_etat_processus)
.position_variable_courante].nom);

if ((*s_etat_processus).erreur_systeme	if ((*s_etat_processus).erreur_systeme
!= d_es)	!= d_es)
Line 4934 evaluation(struct_processus *s_etat_proc	Line 4902 evaluation(struct_processus *s_etat_proc
(((struct_nom ) (*s_objet_elementaire)	(((struct_nom ) (*s_objet_elementaire)
.objet)).nom) == d_vrai)	.objet)).nom) == d_vrai)
{	{
if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet
.position_variable_courante].objet
== NULL)	== NULL)
{	{
// Variable partagée	// Variable partagée
Line 4953 evaluation(struct_processus *s_etat_proc	Line 4920 evaluation(struct_processus *s_etat_proc

if (recherche_variable_partagee(	if (recherche_variable_partagee(
s_etat_processus,	s_etat_processus,
((*s_etat_processus)	((s_etat_processus)
.s_liste_variables	.pointeur_variable_courante).nom,
[(*s_etat_processus)	((s_etat_processus)
.position_variable_courante]).nom,	.pointeur_variable_courante)
((*s_etat_processus)
.s_liste_variables
[(*s_etat_processus)
.position_variable_courante])
.variable_partagee, 'E') == d_vrai)	.variable_partagee, 'E') == d_vrai)
{	{
liberation(s_etat_processus,	liberation(s_etat_processus,
Line 5020 evaluation(struct_processus *s_etat_proc	Line 4983 evaluation(struct_processus *s_etat_proc

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	.pointeur_variable_courante).objet,
[(*s_etat_processus)
.position_variable_courante].objet,
'P')) == NULL)	'P')) == NULL)
{	{
if (presence_egalite == d_vrai)	if (presence_egalite == d_vrai)
Line 5099 evaluation(struct_processus *s_etat_proc	Line 5060 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
	// d'exécution puisqu'on empile une constante
	// symbolique.

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 5198 evaluation(struct_processus *s_etat_proc	Line 5163 evaluation(struct_processus *s_etat_proc

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

for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)	if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
{
if ((*s_etat_processus).s_liste_variables[n].niveau
> niveau_initial)
{
m++;
}
}

registre_variables = (*s_etat_processus).s_liste_variables;
(*s_etat_processus).nombre_variables -= m;

if (((*s_etat_processus).s_liste_variables = malloc(
(s_etat_processus).nombre_variables
sizeof(struct_variable))) == NULL)
{	{
if (presence_egalite == d_vrai)
{
liberation(s_etat_processus, s_objet_evalue);
}

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

for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
{
if (registre_variables[n + m].niveau > niveau_initial)
{
free(registre_variables[n + m].nom);
liberation(s_etat_processus,
registre_variables[n + m].objet);
m++;
n--;
}
else
{
(*s_etat_processus).s_liste_variables[n] =
registre_variables[n + m];
}
}

free(registre_variables);
}	}

/*	/*
Line 5388 evaluation(struct_processus *s_etat_proc	Line 5313 evaluation(struct_processus *s_etat_proc
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
(((struct_fonction ) (*s_objet).objet)).nom_fonction;	(((struct_fonction ) (*s_objet).objet)).nom_fonction;

	registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
	? 'E' : 'N';
	cf(s_etat_processus, 35);

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

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

	if (registre_type_evaluation == 'E')
	{
	sf(s_etat_processus, 35);
	}
	else
	{
	cf(s_etat_processus, 35);
	}

if (((*s_etat_processus).erreur_systeme != d_es) \|\|	if (((*s_etat_processus).erreur_systeme != d_es) \|\|
((*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))
{	{
(*s_etat_processus).instruction_courante = instruction_courante;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
registre_mode_execution_programme;	registre_mode_execution_programme;
return(d_erreur);	return(d_erreur);
Line 5405 evaluation(struct_processus *s_etat_proc	Line 5341 evaluation(struct_processus *s_etat_proc
}	}
else	else
{	{
	(*s_etat_processus).instruction_courante = instruction_courante;

if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))	if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
(*s_etat_processus).instruction_courante = instruction_courante;
return(d_erreur);	return(d_erreur);
}	}

if (empilement(s_etat_processus, &((*s_etat_processus)	if (empilement(s_etat_processus, &((*s_etat_processus)
.l_base_pile), s_objet_tampon) == d_erreur)	.l_base_pile), s_objet_tampon) == d_erreur)
{	{
(*s_etat_processus).instruction_courante = instruction_courante;
return(d_erreur);	return(d_erreur);
}	}
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.9
changed lines
	Added in v.1.36