version 1.1, 2010/01/26 15:22:44
|
version 1.8, 2010/03/09 10:18:43
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.9 |
RPL/2 (R) version 4.0.13 |
Copyright (C) 1989-2010 Dr. BERTRAND Joël |
Copyright (C) 1989-2010 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
Line 82 evaluation(struct_processus *s_etat_proc
|
Line 82 evaluation(struct_processus *s_etat_proc
|
unsigned char *instruction_courante; |
unsigned char *instruction_courante; |
unsigned char *message; |
unsigned char *message; |
unsigned char registre_evaluation_expression_compilee; |
unsigned char registre_evaluation_expression_compilee; |
|
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_retour_definition; |
Line 327 evaluation(struct_processus *s_etat_proc
|
Line 328 evaluation(struct_processus *s_etat_proc
|
} |
} |
} |
} |
|
|
|
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) |
if (sequenceur(s_etat_processus) == d_erreur) |
{ |
{ |
|
(*s_etat_processus).evaluation_forcee = |
|
registre_evaluation_forcee; |
(*s_etat_processus).mode_execution_programme = |
(*s_etat_processus).mode_execution_programme = |
registre_mode_execution_programme; |
registre_mode_execution_programme; |
(*s_etat_processus).instruction_courante = |
(*s_etat_processus).instruction_courante = |
Line 336 evaluation(struct_processus *s_etat_proc
|
Line 347 evaluation(struct_processus *s_etat_proc
|
return(d_erreur); |
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 = 'N'; |
(*s_etat_processus).mode_execution_programme = 'N'; |
Line 864 evaluation(struct_processus *s_etat_proc
|
Line 877 evaluation(struct_processus *s_etat_proc
|
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_superieur); |
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
|
(*s_etat_processus).exception |
(*s_etat_processus).exception |
= registre_exception; |
= registre_exception; |
(*s_etat_processus) |
(*s_etat_processus) |
Line 910 evaluation(struct_processus *s_etat_proc
|
Line 932 evaluation(struct_processus *s_etat_proc
|
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_inferieur); |
vers_niveau_inferieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
|
(*s_etat_processus).exception |
(*s_etat_processus).exception |
= registre_exception; |
= registre_exception; |
(*s_etat_processus) |
(*s_etat_processus) |
Line 1048 evaluation(struct_processus *s_etat_proc
|
Line 1079 evaluation(struct_processus *s_etat_proc
|
{ |
{ |
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_superieur); |
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1081 evaluation(struct_processus *s_etat_proc
|
Line 1121 evaluation(struct_processus *s_etat_proc
|
{ |
{ |
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_inferieur); |
vers_niveau_inferieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1183 evaluation(struct_processus *s_etat_proc
|
Line 1232 evaluation(struct_processus *s_etat_proc
|
{ |
{ |
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_superieur); |
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1216 evaluation(struct_processus *s_etat_proc
|
Line 1274 evaluation(struct_processus *s_etat_proc
|
{ |
{ |
analyse(s_etat_processus, |
analyse(s_etat_processus, |
vers_niveau_inferieur); |
vers_niveau_inferieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 2792 evaluation(struct_processus *s_etat_proc
|
Line 2859 evaluation(struct_processus *s_etat_proc
|
} |
} |
} |
} |
|
|
|
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) |
if (sequenceur(s_etat_processus) == d_erreur) |
{ |
{ |
|
(*s_etat_processus).evaluation_forcee = |
|
registre_evaluation_forcee; |
|
|
if (presence_variable_partagee == d_vrai) |
if (presence_variable_partagee == d_vrai) |
{ |
{ |
(*s_etat_processus).s_liste_variables |
(*s_etat_processus).s_liste_variables |
Line 2822 evaluation(struct_processus *s_etat_proc
|
Line 2900 evaluation(struct_processus *s_etat_proc
|
return(d_erreur); |
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 = 'N'; |
(*s_etat_processus).mode_execution_programme = 'N'; |
Line 3091 evaluation(struct_processus *s_etat_proc
|
Line 3171 evaluation(struct_processus *s_etat_proc
|
registre_test_2 = (*s_etat_processus).test_instruction; |
registre_test_2 = (*s_etat_processus).test_instruction; |
(*s_etat_processus).test_instruction = 'N'; |
(*s_etat_processus).test_instruction = 'N'; |
|
|
|
registre_type_evaluation = (test_cfsf(s_etat_processus, 35) |
|
== d_vrai) ? 'E' : 'N'; |
|
|
|
if (type_evaluation == 'N') |
|
{ |
|
cf(s_etat_processus, 35); |
|
} |
|
else |
|
{ |
|
sf(s_etat_processus, 35); |
|
} |
|
|
analyse(s_etat_processus, NULL); |
analyse(s_etat_processus, NULL); |
|
|
|
if (registre_type_evaluation == 'E') |
|
{ |
|
sf(s_etat_processus, 35); |
|
} |
|
else |
|
{ |
|
cf(s_etat_processus, 35); |
|
} |
|
|
(*s_etat_processus).test_instruction = registre_test_2; |
(*s_etat_processus).test_instruction = registre_test_2; |
|
|
|
if ((*s_etat_processus).erreur_systeme != d_es) |
|
{ |
|
if (presence_egalite == d_vrai) |
|
{ |
|
liberation(s_etat_processus, s_objet_evalue); |
|
} |
|
|
|
if ((*s_etat_processus).var_volatile_processus_pere |
|
== 0) |
|
{ |
|
kill((*s_etat_processus) |
|
.pid_processus_pere, SIGALRM); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).var_volatile_alarme = -1; |
|
} |
|
|
|
(*s_etat_processus).instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
else if (((*s_etat_processus).erreur_execution != d_ex) || |
|
((*s_etat_processus).exception != d_ep)) |
|
{ |
|
if ((*s_etat_processus).arret_si_exception == d_faux) |
|
{ |
|
/* |
|
* Reprise sur erreur |
|
*/ |
|
|
|
if ((message = messages(s_etat_processus)) == NULL) |
|
{ |
|
if (presence_egalite == d_vrai) |
|
{ |
|
liberation(s_etat_processus, |
|
s_objet_evalue); |
|
} |
|
|
|
(*s_etat_processus).instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
|
|
free(message); |
|
|
|
while((*(*s_etat_processus).l_base_pile_systeme) |
|
.clause != 'R') |
|
{ |
|
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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
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) |
|
{ |
|
(*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 |
|
{ |
|
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) |
|
{ |
|
(*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 |
|
{ |
|
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); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
(*s_etat_processus).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).erreur_execution = d_ex; |
|
} |
|
else if ((*s_etat_processus).mode_evaluation_expression |
|
== 'Y') |
|
{ |
|
/* |
|
* Reprise sur erreur |
|
*/ |
|
|
|
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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
TEST(vers_niveau_superieur)) |
|
{ |
|
if (TEST(vers_niveau_superieur)) |
|
{ |
|
analyse(s_etat_processus, |
|
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
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) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
else |
|
{ |
|
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; |
|
|
|
(*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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
TEST(vers_niveau_superieur)) |
|
{ |
|
if (TEST(vers_niveau_superieur)) |
|
{ |
|
analyse(s_etat_processus, |
|
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
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) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
else |
|
{ |
|
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) |
|
{ |
|
liberation(s_etat_processus, s_objet_evalue); |
|
} |
|
|
|
if ((*s_etat_processus) |
|
.var_volatile_processus_pere == 0) |
|
{ |
|
kill((*s_etat_processus) |
|
.pid_processus_pere, SIGALRM); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).var_volatile_alarme = -1; |
|
} |
|
|
|
(*s_etat_processus).erreur_execution = |
|
registre_erreur_execution; |
|
(*s_etat_processus).erreur_systeme = |
|
registre_erreur_systeme; |
|
(*s_etat_processus).exception = |
|
registre_exception; |
|
return(d_erreur); |
|
} |
|
} |
|
|
|
if ((*s_etat_processus).erreur_systeme != d_es) |
|
{ |
|
if (presence_egalite == d_vrai) |
|
{ |
|
liberation(s_etat_processus, s_objet_evalue); |
|
} |
|
|
|
if ((*s_etat_processus).var_volatile_processus_pere |
|
== 0) |
|
{ |
|
kill((*s_etat_processus) |
|
.pid_processus_pere, SIGALRM); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).var_volatile_alarme = -1; |
|
} |
|
|
|
(*s_etat_processus).instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
else if (((*s_etat_processus).erreur_execution != d_ex) || |
|
((*s_etat_processus).exception != d_ep)) |
|
{ |
|
if ((*s_etat_processus).arret_si_exception == d_faux) |
|
{ |
|
/* |
|
* Reprise sur erreur |
|
*/ |
|
|
|
if ((message = messages(s_etat_processus)) == NULL) |
|
{ |
|
if (presence_egalite == d_vrai) |
|
{ |
|
liberation(s_etat_processus, |
|
s_objet_evalue); |
|
} |
|
|
|
(*s_etat_processus).instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
|
|
free(message); |
|
|
|
while((*(*s_etat_processus).l_base_pile_systeme) |
|
.clause != 'R') |
|
{ |
|
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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
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) |
|
{ |
|
(*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 |
|
{ |
|
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) |
|
{ |
|
(*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 |
|
{ |
|
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); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
(*s_etat_processus).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).erreur_execution = d_ex; |
|
} |
|
else if ((*s_etat_processus).mode_evaluation_expression |
|
== 'Y') |
|
{ |
|
/* |
|
* Reprise sur erreur |
|
*/ |
|
|
|
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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
TEST(vers_niveau_superieur)) |
|
{ |
|
if (TEST(vers_niveau_superieur)) |
|
{ |
|
analyse(s_etat_processus, |
|
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
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) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
else |
|
{ |
|
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; |
|
|
|
(*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_start) || |
|
TEST(instruction_select) || |
|
TEST(instruction_case) || |
|
TEST(vers_niveau_superieur)) |
|
{ |
|
if (TEST(vers_niveau_superieur)) |
|
{ |
|
analyse(s_etat_processus, |
|
vers_niveau_superieur); |
|
|
|
if ((*s_etat_processus) |
|
.erreur_systeme != d_es) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
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) |
|
{ |
|
(*s_etat_processus) |
|
.instruction_courante = |
|
instruction_courante; |
|
return(d_erreur); |
|
} |
|
} |
|
else |
|
{ |
|
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) |
|
{ |
|
liberation(s_etat_processus, s_objet_evalue); |
|
} |
|
|
|
if ((*s_etat_processus) |
|
.var_volatile_processus_pere == 0) |
|
{ |
|
kill((*s_etat_processus) |
|
.pid_processus_pere, SIGALRM); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).var_volatile_alarme = -1; |
|
} |
|
|
|
(*s_etat_processus).erreur_execution = |
|
registre_erreur_execution; |
|
(*s_etat_processus).erreur_systeme = |
|
registre_erreur_systeme; |
|
(*s_etat_processus).exception = |
|
registre_exception; |
|
return(d_erreur); |
|
} |
|
} |
} |
} |
else if ((*s_etat_processus).constante_symbolique == 'N') |
else if ((*s_etat_processus).constante_symbolique == 'N') |
{ |
{ |
Line 3316 evaluation(struct_processus *s_etat_proc
|
Line 4579 evaluation(struct_processus *s_etat_proc
|
} |
} |
} |
} |
|
|
|
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) |
if (sequenceur(s_etat_processus) == d_erreur) |
{ |
{ |
|
(*s_etat_processus).evaluation_forcee = |
|
registre_evaluation_forcee; |
|
|
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 3330 evaluation(struct_processus *s_etat_proc
|
Line 4604 evaluation(struct_processus *s_etat_proc
|
return(d_erreur); |
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 = 'N'; |
(*s_etat_processus).mode_execution_programme = 'N'; |