|
version 1.1.1.1, 2010/01/26 15:22:44
|
version 1.6, 2010/02/10 10:14:19
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.0.9 |
RPL/2 (R) version 4.0.11 |
| 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'; |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src