version 1.70, 2013/03/05 16:20:47
|
version 1.104, 2017/01/18 15:44:17
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.13 |
RPL/2 (R) version 4.1.26 |
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_niveau_courant; |
|
unsigned long registre_position_courante; |
|
|
|
void (*fonction)(); |
void (*fonction)(); |
|
|
Line 178 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 238 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 292 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 325 evaluation(struct_processus *s_etat_proc
|
Line 323 evaluation(struct_processus *s_etat_proc
|
|
|
if (sequenceur(s_etat_processus) == d_erreur) |
if (sequenceur(s_etat_processus) == d_erreur) |
{ |
{ |
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).evaluation_forcee = |
(*s_etat_processus).evaluation_forcee = |
registre_evaluation_forcee; |
registre_evaluation_forcee; |
(*s_etat_processus).mode_execution_programme = |
(*s_etat_processus).mode_execution_programme = |
Line 410 evaluation(struct_processus *s_etat_proc
|
Line 410 evaluation(struct_processus *s_etat_proc
|
.niveau_courant = (*s_etat_processus) |
.niveau_courant = (*s_etat_processus) |
.niveau_courant; |
.niveau_courant; |
|
|
empilement_pile_systeme(s_etat_processus); |
|
|
|
if (presence_variable_partagee == d_faux) |
if (presence_variable_partagee == d_faux) |
{ |
{ |
if (evaluation(s_etat_processus, (*(*s_etat_processus) |
if (evaluation(s_etat_processus, (*(*s_etat_processus) |
Line 423 evaluation(struct_processus *s_etat_proc
|
Line 421 evaluation(struct_processus *s_etat_proc
|
profilage(s_etat_processus, NULL); |
profilage(s_etat_processus, NULL); |
} |
} |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).evaluation_expression_compilee = |
(*s_etat_processus).evaluation_expression_compilee = |
registre_evaluation_expression_compilee; |
registre_evaluation_expression_compilee; |
|
|
Line 445 evaluation(struct_processus *s_etat_proc
|
Line 445 evaluation(struct_processus *s_etat_proc
|
profilage(s_etat_processus, NULL); |
profilage(s_etat_processus, NULL); |
} |
} |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).evaluation_expression_compilee = |
(*s_etat_processus).evaluation_expression_compilee = |
registre_evaluation_expression_compilee; |
registre_evaluation_expression_compilee; |
|
|
Line 464 evaluation(struct_processus *s_etat_proc
|
Line 466 evaluation(struct_processus *s_etat_proc
|
} |
} |
|
|
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
|
|
|
if ((*s_etat_processus).erreur_systeme != d_es) |
if ((*s_etat_processus).erreur_systeme != d_es) |
{ |
{ |
Line 570 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 632 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 645 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 709 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'; |
|
/* |
|
(*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour = |
|
s_objet; |
|
*/ |
|
|
|
l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
autorisation_empilement_programme = (*s_etat_processus) |
autorisation_empilement_programme = (*s_etat_processus) |
.autorisation_empilement_programme; |
.autorisation_empilement_programme; |
Line 738 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 765 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 803 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 883 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 1032 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 1149 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 1275 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 1398 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 1515 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 1614 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 1652 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 1783 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 1900 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 1997 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 2022 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 2208 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 2317 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 2337 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 2627 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 2935 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 3099 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 3256 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 3386 evaluation(struct_processus *s_etat_proc
|
Line 3531 evaluation(struct_processus *s_etat_proc
|
liberation(s_etat_processus, s_objet_evalue); |
liberation(s_etat_processus, s_objet_evalue); |
} |
} |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).instruction_courante = |
(*s_etat_processus).instruction_courante = |
instruction_courante; |
instruction_courante; |
return(d_erreur); |
return(d_erreur); |
Line 3405 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 3470 evaluation(struct_processus *s_etat_proc
|
Line 3616 evaluation(struct_processus *s_etat_proc
|
liberation(s_etat_processus, s_objet_evalue); |
liberation(s_etat_processus, s_objet_evalue); |
} |
} |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).instruction_courante = |
(*s_etat_processus).instruction_courante = |
instruction_courante; |
instruction_courante; |
(*s_etat_processus).mode_execution_programme = |
(*s_etat_processus).mode_execution_programme = |
Line 3670 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 3781 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 3860 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 4009 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 4126 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 4212 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 4251 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 4293 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 4416 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 4533 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 4628 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 4666 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 4789 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 4906 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 5003 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 5031 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 5066 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 5110 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 5259 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 5376 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 5462 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 5506 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 5543 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 5666 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 5783 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 5871 evaluation(struct_processus *s_etat_proc
|
Line 6022 evaluation(struct_processus *s_etat_proc
|
(*s_etat_processus).instruction_courante = |
(*s_etat_processus).instruction_courante = |
instruction_courante; |
instruction_courante; |
|
|
|
(*s_etat_processus).exception = d_ep; |
|
(*s_etat_processus).erreur_execution = d_ex; |
|
|
|
erreur_evaluation = d_erreur; |
|
} |
|
else |
|
{ |
|
// On ne détruit pas les variables pour les inclure |
|
// dans le fichier rpl-core. |
|
|
|
(*s_etat_processus).gel_liste_variables = d_vrai; |
|
|
|
registre_erreur_execution = |
|
(*s_etat_processus).erreur_execution; |
|
registre_exception = |
|
(*s_etat_processus).exception; |
|
registre_erreur_systeme = |
|
(*s_etat_processus).erreur_systeme; |
|
|
|
(*s_etat_processus).s_objet_errone = s_objet; |
|
(*s_etat_processus).s_objet_erreur = |
|
(*l_element_courant).donnee; |
|
|
|
l_element_courant = (*l_element_courant).suivant; |
|
|
|
while(l_element_courant != NULL) |
|
{ |
|
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; |
|
|
|
if (recherche_variable(s_etat_processus, |
|
(*s_etat_processus) |
|
.instruction_courante) == d_faux) |
|
{ |
|
(*s_etat_processus).erreur_systeme |
|
= d_es; |
|
|
|
/* |
|
* 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)) |
|
{ |
|
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); |
|
} |
|
} |
|
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)) |
|
{ |
|
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); |
|
} |
|
} |
|
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; |
|
|
|
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) |
|
.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); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
l_element_courant = |
|
(*l_element_courant).suivant; |
|
} |
|
|
|
(*s_etat_processus).mode_execution_programme = |
|
registre_mode_execution_programme; |
|
(*s_etat_processus).instruction_courante = |
|
instruction_courante; |
if (presence_egalite == d_vrai) |
if (presence_egalite == d_vrai) |
{ |
{ |
liberation(s_etat_processus, s_objet_evalue); |
liberation(s_etat_processus, s_objet_evalue); |
Line 5880 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 5959 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 6050 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 6120 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 6128 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 6165 evaluation(struct_processus *s_etat_proc
|
Line 6689 evaluation(struct_processus *s_etat_proc
|
s_objet_evalue); |
s_objet_evalue); |
} |
} |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).instruction_courante = |
(*s_etat_processus).instruction_courante = |
instruction_courante; |
instruction_courante; |
(*s_etat_processus).mode_execution_programme = |
(*s_etat_processus).mode_execution_programme = |
Line 6351 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 6373 evaluation(struct_processus *s_etat_proc
|
Line 7252 evaluation(struct_processus *s_etat_proc
|
(*(*s_etat_processus).l_base_pile_systeme) |
(*(*s_etat_processus).l_base_pile_systeme) |
.niveau_courant = (*s_etat_processus) |
.niveau_courant = (*s_etat_processus) |
.niveau_courant; |
.niveau_courant; |
empilement_pile_systeme(s_etat_processus); |
|
|
|
if (evaluation(s_etat_processus, |
if (evaluation(s_etat_processus, |
s_copie_variable_partagee, |
s_copie_variable_partagee, |
type_evaluation) == d_erreur) |
type_evaluation) == d_erreur) |
{ |
{ |
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
|
|
|
liberation(s_etat_processus, |
liberation(s_etat_processus, |
s_copie_variable_partagee); |
s_copie_variable_partagee); |
Line 6408 evaluation(struct_processus *s_etat_proc
|
Line 7285 evaluation(struct_processus *s_etat_proc
|
} |
} |
|
|
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
depilement_pile_systeme(s_etat_processus); |
|
|
|
liberation(s_etat_processus, |
liberation(s_etat_processus, |
s_copie_variable_partagee); |
s_copie_variable_partagee); |
Line 6449 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 6466 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 6523 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 6607 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 6705 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 6727 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 6745 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 6764 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 6775 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 6794 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 6809 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 6819 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 6829 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); |