--- rpl/src/evaluation.c 2010/01/26 15:22:44 1.1 +++ rpl/src/evaluation.c 2010/01/27 22:22:10 1.2 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.0.9 + RPL/2 (R) version 4.0.10 Copyright (C) 1989-2010 Dr. BERTRAND Joël This file is part of RPL/2. @@ -864,6 +864,15 @@ evaluation(struct_processus *s_etat_proc 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) @@ -910,6 +919,15 @@ evaluation(struct_processus *s_etat_proc 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) @@ -1048,6 +1066,15 @@ evaluation(struct_processus *s_etat_proc { 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 { @@ -1081,6 +1108,15 @@ evaluation(struct_processus *s_etat_proc { 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 { @@ -1183,6 +1219,15 @@ evaluation(struct_processus *s_etat_proc { 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 { @@ -1216,6 +1261,15 @@ evaluation(struct_processus *s_etat_proc { 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 { @@ -3094,6 +3148,1174 @@ evaluation(struct_processus *s_etat_proc analyse(s_etat_processus, NULL); (*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; + + (*s_etat_processus).expression_courante = + registre_expression_courante; + } + 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; + + (*s_etat_processus).expression_courante = + registre_expression_courante; + } + 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') {