--- rpl/src/evaluation.c 2010/01/26 15:22:44 1.1 +++ rpl/src/evaluation.c 2011/06/24 20:31:35 1.42 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.9 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.0.prerelease.4 + Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" #define TEST(instruction) (fonction == instruction) #define vers_niveau_inferieur instruction_vers_niveau_inferieur @@ -76,12 +76,11 @@ evaluation(struct_processus *s_etat_proc struct_objet *s_sous_objet; struct_objet *s_copie_variable_partagee; - struct_variable *registre_variables; - unsigned char autorisation_empilement_programme; unsigned char *instruction_courante; unsigned char *message; unsigned char registre_evaluation_expression_compilee; + unsigned char registre_evaluation_forcee; unsigned char registre_instruction_valide; unsigned char registre_mode_execution_programme; unsigned char registre_retour_definition; @@ -96,7 +95,6 @@ evaluation(struct_processus *s_etat_proc unsigned long k; unsigned long l; unsigned long n; - unsigned long m; unsigned long niveau_initial; unsigned long nombre_termes; unsigned long registre_hauteur_pile_operationnelle; @@ -142,6 +140,34 @@ evaluation(struct_processus *s_etat_proc if (recherche_variable(s_etat_processus, (*((struct_nom *) (*s_objet_tampon).objet)).nom) == d_faux) { + (*s_etat_processus).erreur_execution = d_ex; + + if ((*s_etat_processus).autorisation_nom_implicite == 'N') + { + if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole == + d_faux) + { + if (test_cfsf(s_etat_processus, 31) == d_vrai) + { + if (empilement_pile_last(s_etat_processus, 0) + == d_erreur) + { + return(d_erreur); + } + } + + erreur_evaluation = d_erreur; + (*s_etat_processus).erreur_execution = + d_ex_nom_implicite; + + if (type_evaluation == 'I') + { + (*s_etat_processus).derniere_erreur_evaluation = + (*s_etat_processus).erreur_execution; + } + } + } + (*s_etat_processus).erreur_systeme = d_es; presence_variable = d_faux; } @@ -149,8 +175,7 @@ evaluation(struct_processus *s_etat_proc { if ((*s_etat_processus).traitement_symbolique == 'N') { - if ((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] + if ((*(*s_etat_processus).pointeur_variable_courante) .objet == NULL) { // Variable partagée @@ -166,12 +191,10 @@ evaluation(struct_processus *s_etat_proc presence_variable_partagee = d_faux; if (recherche_variable_partagee(s_etat_processus, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).nom, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]) + (*(*s_etat_processus) + .pointeur_variable_courante).nom, + (*(*s_etat_processus) + .pointeur_variable_courante) .variable_partagee, 'E') == d_vrai) { presence_variable = d_vrai; @@ -240,9 +263,8 @@ evaluation(struct_processus *s_etat_proc presence_variable = d_vrai; - if ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] - .objet)).type == ADR) + if ((*(*(*s_etat_processus).pointeur_variable_courante) + .objet).type == ADR) { presence_fonction = d_vrai; } @@ -293,10 +315,8 @@ evaluation(struct_processus *s_etat_proc { (*s_etat_processus).position_courante = (*((unsigned long *) - ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).objet))); + ((*(*(*s_etat_processus).pointeur_variable_courante) + .objet).objet))); } else { @@ -317,8 +337,7 @@ evaluation(struct_processus *s_etat_proc if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, - (*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] + (*(*s_etat_processus).pointeur_variable_courante) .nom); if ((*s_etat_processus).erreur_systeme != d_es) @@ -327,8 +346,18 @@ 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) { + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; (*s_etat_processus).mode_execution_programme = registre_mode_execution_programme; (*s_etat_processus).instruction_courante = @@ -336,6 +365,8 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; (*s_etat_processus).instruction_courante = instruction_courante; (*s_etat_processus).mode_execution_programme = 'N'; @@ -358,11 +389,9 @@ evaluation(struct_processus *s_etat_proc registre_evaluation_expression_compilee = (*s_etat_processus).evaluation_expression_compilee; - if (((*s_etat_processus).s_liste_variables[(*s_etat_processus) - .position_variable_courante].origine == 'E') && - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante].niveau - == 0)) + if (((*(*s_etat_processus).pointeur_variable_courante).origine + == 'E') && ((*(*s_etat_processus) + .pointeur_variable_courante).niveau == 0)) { (*s_etat_processus).evaluation_expression_compilee = 'Y'; } @@ -374,8 +403,7 @@ evaluation(struct_processus *s_etat_proc if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, - (*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] + (*(*s_etat_processus).pointeur_variable_courante) .nom); if ((*s_etat_processus).erreur_systeme != d_es) @@ -395,11 +423,41 @@ evaluation(struct_processus *s_etat_proc } } + autorisation_empilement_programme = (*s_etat_processus) + .autorisation_empilement_programme; + + empilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + if (presence_variable_partagee == d_vrai) + { + liberation(s_etat_processus, s_copie_variable_partagee); + } + + (*s_etat_processus).instruction_courante = + instruction_courante; + return(d_erreur); + } + + (*(*s_etat_processus).l_base_pile_systeme) + .retour_definition = 'Y'; + (*(*s_etat_processus).l_base_pile_systeme) + .origine_routine_evaluation = 'Y'; + + (*s_etat_processus).mode_execution_programme = 'Y'; + (*s_etat_processus).autorisation_empilement_programme = 'N'; + + (*(*s_etat_processus).l_base_pile_systeme) + .niveau_courant = (*s_etat_processus) + .niveau_courant; + + empilement_pile_systeme(s_etat_processus); + if (presence_variable_partagee == d_faux) { - if (evaluation(s_etat_processus, (*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante].objet, + if (evaluation(s_etat_processus, (*(*s_etat_processus) + .pointeur_variable_courante).objet, type_evaluation) == d_erreur) { if ((*s_etat_processus).profilage == d_vrai) @@ -447,13 +505,23 @@ evaluation(struct_processus *s_etat_proc profilage(s_etat_processus, NULL); } + depilement_pile_systeme(s_etat_processus); + depilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + return(d_erreur); + } + (*s_etat_processus).evaluation_expression_compilee = registre_evaluation_expression_compilee; + (*s_etat_processus).autorisation_empilement_programme = + autorisation_empilement_programme; } - else + else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite) { if ((s_objet_tampon = copie_objet(s_etat_processus, - s_objet, 'P')) == NULL) + s_objet, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -471,12 +539,6 @@ evaluation(struct_processus *s_etat_proc instruction_courante; return(d_erreur); } - - if ((*s_etat_processus).erreur_execution == - d_ex_variable_non_definie) - { - (*s_etat_processus).erreur_execution = d_ex; - } } } else @@ -695,6 +757,8 @@ evaluation(struct_processus *s_etat_proc registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme) .retour_definition; (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N'; + (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour = + s_objet; l_element_courant = (struct_liste_chainee *) (*s_objet).objet; autorisation_empilement_programme = (*s_etat_processus) @@ -794,8 +858,9 @@ evaluation(struct_processus *s_etat_proc free(message); - while((*(*s_etat_processus).l_base_pile_systeme) - .clause != 'R') + drapeau_then = d_faux; + + while(drapeau_then == d_faux) { l_registre_atome = l_element_courant; l_element_courant = @@ -864,6 +929,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 +984,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) @@ -939,66 +1022,28 @@ evaluation(struct_processus *s_etat_proc } } } + else if (TEST(instruction_then)) + { + if ((*(*s_etat_processus) + .l_base_pile_systeme) + .clause == 'R') + { + (*(*s_etat_processus) + .l_base_pile_systeme) + .clause = 'X'; + instruction_then( + s_etat_processus); + drapeau_then = d_vrai; + } + } } } } + (*s_etat_processus).expression_courante = + l_element_courant; (*s_etat_processus).instruction_courante = 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; @@ -1048,6 +1093,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,29 +1135,38 @@ evaluation(struct_processus *s_etat_proc { analyse(s_etat_processus, vers_niveau_inferieur); - } - 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); } } + 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); + } } } } @@ -1183,6 +1246,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 +1288,23 @@ 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); + } + + if ((*(*s_etat_processus) + .l_base_pile_systeme) + .retour_definition + == 'Y') + { + break; + } } else { @@ -1571,9 +1660,8 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } - if ((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] - .objet == NULL) + if ((*(*s_etat_processus).pointeur_variable_courante).objet + == NULL) { if (pthread_mutex_lock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) @@ -1583,22 +1671,18 @@ evaluation(struct_processus *s_etat_proc } if (recherche_variable_partagee(s_etat_processus, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).nom, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]) - .variable_partagee, 'E') == d_vrai) + (*(*s_etat_processus) + .pointeur_variable_courante).nom, + (*(*s_etat_processus) + .pointeur_variable_courante).variable_partagee, + 'E') == d_vrai) { // Une variable partagée existe. presence_variable_partagee = d_vrai; - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet = - (*(*s_etat_processus) + (*(*s_etat_processus).pointeur_variable_courante) + .objet = (*(*s_etat_processus) .s_liste_variables_partagees).table [(*(*s_etat_processus) .s_liste_variables_partagees) @@ -1625,8 +1709,7 @@ evaluation(struct_processus *s_etat_proc * Recherche d'un élément dans un vecteur */ - if (((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) + if ((*(*s_etat_processus).pointeur_variable_courante) .objet == NULL) { // La variable partagée n'existe plus. @@ -1639,9 +1722,8 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet = + (*(*s_etat_processus) + .pointeur_variable_courante).objet = NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) @@ -1658,15 +1740,12 @@ evaluation(struct_processus *s_etat_proc return(d_erreur);; } } - else if ((((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == VIN) || - ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == VRL) || - ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == VCX)) + else if ((((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VIN) || + ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VRL) || + ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VCX)) && ((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments == 1)) { @@ -1677,9 +1756,8 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet = + (*(*s_etat_processus) + .pointeur_variable_courante).objet = NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) @@ -1705,16 +1783,15 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } - if ((*s_objet_indice_i).type == INT) + if ((*s_objet_indice_i).type != INT) { liberation(s_etat_processus, s_objet_indice_i); free(s_objet_elementaire); if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet = + (*(*s_etat_processus) + .pointeur_variable_courante).objet = NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) @@ -1745,18 +1822,16 @@ evaluation(struct_processus *s_etat_proc liberation(s_etat_processus, s_objet_indice_i); if ((i < 1) || (i > (integer8) (*((struct_vecteur *) - (*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).objet)) .taille)) { free(s_objet_elementaire); if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet = + (*(*s_etat_processus) + .pointeur_variable_courante).objet = NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) @@ -1782,9 +1857,8 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } - if ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)).type + if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VIN) { if (((*s_objet_elementaire).objet = malloc(sizeof( @@ -1798,10 +1872,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -1823,14 +1896,12 @@ evaluation(struct_processus *s_etat_proc (*s_objet_elementaire).type = INT; (*((integer8 *) (*s_objet_elementaire).objet)) = ((integer8 *) (*((struct_vecteur *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1]; } - else if ((*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).type + else if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VRL) { if (((*s_objet_elementaire).objet = malloc(sizeof( @@ -1838,10 +1909,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -1869,14 +1939,12 @@ evaluation(struct_processus *s_etat_proc (*s_objet_elementaire).type = REL; (*((real8 *) (*s_objet_elementaire).objet)) = ((real8 *) (*((struct_vecteur *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1]; } - else if ((*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).type + else if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == VCX) { if (((*s_objet_elementaire).objet = malloc(sizeof( @@ -1884,10 +1952,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -1916,19 +1983,15 @@ evaluation(struct_processus *s_etat_proc (*((struct_complexe16 *) (*s_objet_elementaire) .objet)).partie_reelle = ((struct_complexe16 *) (*((struct_vecteur *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) - .objet)).tableau)[i - 1] - .partie_reelle; + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) + .objet)).tableau)[i - 1].partie_reelle; (*((struct_complexe16 *) (*s_objet_elementaire) .objet)).partie_imaginaire = ((struct_complexe16 *) (*((struct_vecteur *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) - .objet)).tableau)[i - 1] - .partie_imaginaire; + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) + .objet)).tableau)[i - 1].partie_imaginaire; } } @@ -1936,15 +1999,12 @@ evaluation(struct_processus *s_etat_proc * Recherche d'un élément dans une matrice */ - else if ((((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == MIN) || - ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == MRL) || - ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == MCX)) + else if ((((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == MIN) || + ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == MRL) || + ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == MCX)) && ((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments == 2)) { @@ -1955,10 +2015,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -1992,10 +2051,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2030,10 +2088,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2066,25 +2123,20 @@ evaluation(struct_processus *s_etat_proc liberation(s_etat_processus, s_objet_indice_j); if ((i < 1) || (i > (integer8) (*((struct_matrice *) - (*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).objet)) .nombre_lignes) || (j < 1) || (j > (integer8) - (*((struct_matrice *) (*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).objet)) + (*((struct_matrice *) (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).objet)) .nombre_colonnes)) { - liberation(s_etat_processus, s_objet_indice_i); - liberation(s_etat_processus, s_objet_indice_j); free(s_objet_elementaire); if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2110,20 +2162,17 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } - if ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)).type - == MIN) + if ((*((*(*s_etat_processus).pointeur_variable_courante) + .objet)).type == MIN) { if (((*s_objet_elementaire).objet = malloc(sizeof( integer8))) == NULL) { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2151,14 +2200,12 @@ evaluation(struct_processus *s_etat_proc (*s_objet_elementaire).type = INT; (*((integer8 *) (*s_objet_elementaire).objet)) = ((integer8 **) (*((struct_matrice *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1][j - 1]; } - else if ((*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).type + else if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == MRL) { if (((*s_objet_elementaire).objet = malloc(sizeof( @@ -2166,10 +2213,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2197,14 +2243,12 @@ evaluation(struct_processus *s_etat_proc (*s_objet_elementaire).type = REL; (*((real8 *) (*s_objet_elementaire).objet)) = ((real8 **) (*((struct_matrice *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1][j - 1]; } - else if ((*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).type + else if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == MCX) { if (((*s_objet_elementaire).objet = malloc(sizeof( @@ -2212,10 +2256,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2245,18 +2288,16 @@ evaluation(struct_processus *s_etat_proc .objet)).partie_reelle = ((struct_complexe16 **) (*((struct_matrice *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1][j - 1] .partie_reelle; (*((struct_complexe16 *) (*s_objet_elementaire) .objet)).partie_imaginaire = ((struct_complexe16 **) (*((struct_matrice *) - (*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet)) + (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)) .objet)).tableau)[i - 1][j - 1] .partie_imaginaire; } @@ -2266,9 +2307,8 @@ evaluation(struct_processus *s_etat_proc * Recherche de l'élément idoine dans la liste */ - else if (((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == LST) && + else if (((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == LST) && ((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments == 1)) { @@ -2279,10 +2319,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2315,10 +2354,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2348,9 +2386,8 @@ evaluation(struct_processus *s_etat_proc liberation(s_etat_processus, s_objet_indice_i); - l_sous_element_courant = (*(((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet)).objet; + l_sous_element_courant = (*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).objet; j = 0; while(l_sous_element_courant != NULL) @@ -2370,10 +2407,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2407,10 +2443,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2439,9 +2474,8 @@ evaluation(struct_processus *s_etat_proc * Recherche de l'élément idoine dans la table */ - else if (((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == TAB) && + else if (((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == TBL) && ((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments == 1)) { @@ -2452,10 +2486,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2488,10 +2521,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2522,19 +2554,17 @@ evaluation(struct_processus *s_etat_proc liberation(s_etat_processus, s_objet_indice_i); if ((i < 1) || (i > (integer8) (*((struct_tableau *) - (*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet) + (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .objet)).nombre_elements)) { free(s_objet_elementaire); if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2564,17 +2594,15 @@ evaluation(struct_processus *s_etat_proc if ((s_objet_elementaire = copie_objet(s_etat_processus, - (*((struct_tableau *) (*((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet) + (*((struct_tableau *) (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .objet)).elements[i - 1], 'P')) == NULL) { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2598,23 +2626,18 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } } - else if (((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == ALG) || - ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == RPN)) + else if (((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == ALG) || + ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == RPN)) { registre_evaluation_expression_compilee = (*s_etat_processus) .evaluation_expression_compilee; - if (((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].origine == 'E') && - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante] - .niveau == 0)) + if (((*(*s_etat_processus).pointeur_variable_courante) + .origine == 'E') && ((*(*s_etat_processus) + .pointeur_variable_courante).niveau == 0)) { (*s_etat_processus).evaluation_expression_compilee = 'Y'; @@ -2625,9 +2648,8 @@ evaluation(struct_processus *s_etat_proc 'N'; } - if (evaluation(s_etat_processus, (*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante].objet, + if (evaluation(s_etat_processus, (*(*s_etat_processus) + .pointeur_variable_courante).objet, type_evaluation) == d_erreur) { (*s_etat_processus).evaluation_expression_compilee = @@ -2635,10 +2657,9 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2673,10 +2694,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2702,9 +2722,8 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } } - else if ((*(((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) - .objet)).type == ADR) + else if ((*((*(*s_etat_processus) + .pointeur_variable_courante).objet)).type == ADR) { autorisation_empilement_programme = (*s_etat_processus) .autorisation_empilement_programme; @@ -2717,10 +2736,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2757,26 +2775,22 @@ evaluation(struct_processus *s_etat_proc (*s_etat_processus).position_courante = (*((unsigned long *) - ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).objet))); + ((*(*(*s_etat_processus) + .pointeur_variable_courante).objet).objet))); if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].nom); + (*(*s_etat_processus) + .pointeur_variable_courante).nom); if ((*s_etat_processus).erreur_systeme != d_es) { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock( &((*(*s_etat_processus) @@ -2792,14 +2806,24 @@ 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) { + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; + if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees) @@ -2822,6 +2846,8 @@ evaluation(struct_processus *s_etat_proc return(d_erreur); } + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; (*s_etat_processus).instruction_courante = instruction_courante; (*s_etat_processus).mode_execution_programme = 'N'; @@ -2832,10 +2858,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees) @@ -2868,10 +2893,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) @@ -2900,10 +2924,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees) .mutex)) != 0) @@ -2933,10 +2956,9 @@ evaluation(struct_processus *s_etat_proc { if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = + NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) @@ -2958,10 +2980,8 @@ evaluation(struct_processus *s_etat_proc if (presence_variable_partagee == d_vrai) { - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet - = NULL; + (*(*s_etat_processus) + .pointeur_variable_courante).objet = NULL; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) @@ -3091,9 +3111,1192 @@ evaluation(struct_processus *s_etat_proc registre_test_2 = (*s_etat_processus).test_instruction; (*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); + if (registre_type_evaluation == 'E') + { + sf(s_etat_processus, 35); + } + else + { + cf(s_etat_processus, 35); + } + (*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 séquenceur 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') { @@ -3120,14 +4323,42 @@ evaluation(struct_processus *s_etat_proc { (*s_etat_processus).erreur_systeme = d_es; presence_variable = d_faux; + + if ((*s_etat_processus).autorisation_nom_implicite + == 'N') + { + if ((*((struct_nom *) (*s_objet_elementaire).objet)) + .symbole == d_faux) + { + if (test_cfsf(s_etat_processus, 31) == d_vrai) + { + if (empilement_pile_last(s_etat_processus, + 0) == d_erreur) + { + return(d_erreur); + } + } + + erreur_evaluation = d_erreur; + (*s_etat_processus).erreur_execution = + d_ex_nom_implicite; + + if (type_evaluation == 'I') + { + (*s_etat_processus) + .derniere_erreur_evaluation = + (*s_etat_processus) + .erreur_execution; + } + } + } } else { if ((*s_etat_processus).traitement_symbolique == 'N') { - if ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet == NULL) + if ((*(*s_etat_processus) + .pointeur_variable_courante).objet == NULL) { // Variable partagée @@ -3143,13 +4374,10 @@ evaluation(struct_processus *s_etat_proc presence_variable_partagee = d_faux; if (recherche_variable_partagee( - s_etat_processus, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).nom, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]) + s_etat_processus, (*(*s_etat_processus) + .pointeur_variable_courante).nom, + (*(*s_etat_processus) + .pointeur_variable_courante) .variable_partagee, 'E') == d_vrai) { presence_variable = d_vrai; @@ -3227,11 +4455,9 @@ evaluation(struct_processus *s_etat_proc { presence_variable = d_vrai; - if ((*((*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).type == ADR) + if ((*(*(*s_etat_processus) + .pointeur_variable_courante).objet) + .type == ADR) { presence_fonction = d_vrai; } @@ -3247,110 +4473,157 @@ evaluation(struct_processus *s_etat_proc if (presence_fonction == d_vrai) { - autorisation_empilement_programme = (*s_etat_processus) - .autorisation_empilement_programme; - registre_position_courante = (*s_etat_processus) - .position_courante; + if ((*((struct_nom *) (*(*l_element_courant).donnee) + .objet)).symbole == d_vrai) + { + // L'objet apparaît comme un symbole dans + // l'expression en cours d'évaluation. On se + // contente de l'empiler. - empilement_pile_systeme(s_etat_processus); + if ((s_sous_objet = copie_objet(s_etat_processus, + (*l_element_courant).donnee, 'P')) == NULL) + { + (*s_etat_processus).instruction_courante = + instruction_courante; - if ((*s_etat_processus).erreur_systeme != d_es) - { - if (presence_variable_partagee == d_vrai) + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(d_erreur); + } + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_sous_objet) == d_erreur) { - liberation(s_etat_processus, - s_copie_variable_partagee); + (*s_etat_processus).instruction_courante = + instruction_courante; + liberation(s_etat_processus, s_sous_objet); + return(d_erreur); } + } + else + { + autorisation_empilement_programme = + (*s_etat_processus) + .autorisation_empilement_programme; + registre_position_courante = (*s_etat_processus) + .position_courante; - if (presence_egalite == d_vrai) + empilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) { - liberation(s_etat_processus, s_objet_evalue); + if (presence_variable_partagee == d_vrai) + { + liberation(s_etat_processus, + s_copie_variable_partagee); + } + + if (presence_egalite == d_vrai) + { + liberation(s_etat_processus, + s_objet_evalue); + } + + (*s_etat_processus).instruction_courante = + instruction_courante; + return(d_erreur); } - (*s_etat_processus).instruction_courante = - instruction_courante; - return(d_erreur); - } + (*(*s_etat_processus).l_base_pile_systeme) + .retour_definition = 'Y'; + (*(*s_etat_processus).l_base_pile_systeme) + .origine_routine_evaluation = 'Y'; - (*(*s_etat_processus).l_base_pile_systeme) - .retour_definition = 'Y'; - (*(*s_etat_processus).l_base_pile_systeme) - .origine_routine_evaluation = 'Y'; + (*s_etat_processus).mode_execution_programme = 'Y'; + (*s_etat_processus) + .autorisation_empilement_programme = 'N'; - (*s_etat_processus).mode_execution_programme = 'Y'; - (*s_etat_processus).autorisation_empilement_programme - = 'N'; + (*(*s_etat_processus).l_base_pile_systeme) + .niveau_courant = (*s_etat_processus) + .niveau_courant; - (*(*s_etat_processus).l_base_pile_systeme) - .niveau_courant = (*s_etat_processus) - .niveau_courant; + if (presence_variable_partagee == d_faux) + { + (*s_etat_processus).position_courante = + (*((unsigned long *) + ((*(*(*s_etat_processus) + .pointeur_variable_courante) + .objet).objet))); + } + else + { + (*s_etat_processus).position_courante = + (*((unsigned long *) + (*s_copie_variable_partagee).objet)); + liberation(s_etat_processus, + s_copie_variable_partagee); + } - if (presence_variable_partagee == d_faux) - { - (*s_etat_processus).position_courante = - (*((unsigned long *) - ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).objet))); - } - else - { - (*s_etat_processus).position_courante = - (*((unsigned long *) - (*s_copie_variable_partagee).objet)); - liberation(s_etat_processus, - s_copie_variable_partagee); - } + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, + (*(*s_etat_processus) + .pointeur_variable_courante).nom); - if ((*s_etat_processus).profilage == d_vrai) - { - profilage(s_etat_processus, - (*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].nom); + if ((*s_etat_processus).erreur_systeme != d_es) + { + return(d_erreur); + } + } - if ((*s_etat_processus).erreur_systeme != d_es) + registre_evaluation_forcee = + (*s_etat_processus).evaluation_forcee; + + if (type_evaluation == 'N') { - return(d_erreur); + (*s_etat_processus).evaluation_forcee = 'Y'; } - } - if (sequenceur(s_etat_processus) == d_erreur) - { - if (presence_egalite == d_vrai) + if (sequenceur(s_etat_processus) == d_erreur) { - liberation(s_etat_processus, s_objet_evalue); + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; + + if (presence_egalite == d_vrai) + { + liberation(s_etat_processus, + s_objet_evalue); + } + + (*s_etat_processus).instruction_courante = + instruction_courante; + (*s_etat_processus).mode_execution_programme = + registre_mode_execution_programme; + return(d_erreur); } + (*s_etat_processus).evaluation_forcee = + registre_evaluation_forcee; (*s_etat_processus).instruction_courante = instruction_courante; - (*s_etat_processus).mode_execution_programme = - registre_mode_execution_programme; - return(d_erreur); - } + (*s_etat_processus).mode_execution_programme = 'N'; - (*s_etat_processus).instruction_courante = - instruction_courante; - (*s_etat_processus).mode_execution_programme = 'N'; + depilement_pile_systeme(s_etat_processus); - depilement_pile_systeme(s_etat_processus); - - if ((*s_etat_processus).erreur_systeme != d_es) - { - if (presence_egalite == d_vrai) + if ((*s_etat_processus).erreur_systeme != d_es) { - liberation(s_etat_processus, s_objet_evalue); + if (presence_egalite == d_vrai) + { + liberation(s_etat_processus, + s_objet_evalue); + } + + return(d_erreur); } - return(d_erreur); + (*s_etat_processus).retour_routine_evaluation = 'N'; + (*s_etat_processus).position_courante = + registre_position_courante; + (*s_etat_processus) + .autorisation_empilement_programme = + autorisation_empilement_programme; } - - (*s_etat_processus).retour_routine_evaluation = 'N'; - (*s_etat_processus).position_courante = - registre_position_courante; - (*s_etat_processus).autorisation_empilement_programme = - autorisation_empilement_programme; } else if (((type_evaluation == 'N') || ((*((struct_nom *) (*(*l_element_courant).donnee).objet)).symbole == @@ -3362,9 +4635,8 @@ evaluation(struct_processus *s_etat_proc { if ((s_sous_objet = copie_objet(s_etat_processus, - (*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante].objet, + (*(*s_etat_processus) + .pointeur_variable_courante).objet, 'P')) == NULL) { if (presence_variable_partagee == d_vrai) @@ -3433,12 +4705,10 @@ evaluation(struct_processus *s_etat_proc (*s_etat_processus) .evaluation_expression_compilee; - if (((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].origine == 'E') - && ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].niveau == 0)) + if (((*(*s_etat_processus) + .pointeur_variable_courante) + .origine == 'E') && ((*(*s_etat_processus) + .pointeur_variable_courante).niveau == 0)) { (*s_etat_processus) .evaluation_expression_compilee = 'Y'; @@ -3454,10 +4724,8 @@ evaluation(struct_processus *s_etat_proc if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, - (*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante].nom); + (*(*s_etat_processus) + .pointeur_variable_courante).nom); if ((*s_etat_processus).erreur_systeme != d_es) @@ -3480,15 +4748,15 @@ evaluation(struct_processus *s_etat_proc empilement_pile_systeme(s_etat_processus); if (evaluation(s_etat_processus, - (*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante].objet, + (*(*s_etat_processus) + .pointeur_variable_courante).objet, type_evaluation) == d_erreur) { depilement_pile_systeme(s_etat_processus); (*(*s_etat_processus).l_base_pile_systeme) .niveau_courant = + registre_niveau_courant; (*(*s_etat_processus).l_base_pile_systeme) .retour_definition = registre_retour_definition; @@ -3519,6 +4787,7 @@ evaluation(struct_processus *s_etat_proc (*(*s_etat_processus).l_base_pile_systeme) .niveau_courant = + registre_niveau_courant; (*(*s_etat_processus).l_base_pile_systeme) .retour_definition = registre_retour_definition; @@ -3528,10 +4797,8 @@ evaluation(struct_processus *s_etat_proc if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, - (*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante].nom); + (*(*s_etat_processus) + .pointeur_variable_courante).nom); if ((*s_etat_processus).erreur_systeme != d_es) @@ -3635,9 +4902,8 @@ evaluation(struct_processus *s_etat_proc (*((struct_nom *) (*s_objet_elementaire) .objet)).nom) == d_vrai) { - if ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet + if ((*(*s_etat_processus) + .pointeur_variable_courante).objet == NULL) { // Variable partagée @@ -3654,14 +4920,10 @@ evaluation(struct_processus *s_etat_proc if (recherche_variable_partagee( s_etat_processus, - ((*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).nom, - ((*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante]) + (*(*s_etat_processus) + .pointeur_variable_courante).nom, + (*(*s_etat_processus) + .pointeur_variable_courante) .variable_partagee, 'E') == d_vrai) { liberation(s_etat_processus, @@ -3721,10 +4983,8 @@ evaluation(struct_processus *s_etat_proc if ((s_objet_elementaire = copie_objet(s_etat_processus, - (*s_etat_processus) - .s_liste_variables - [(*s_etat_processus) - .position_variable_courante].objet, + (*(*s_etat_processus) + .pointeur_variable_courante).objet, 'P')) == NULL) { if (presence_egalite == d_vrai) @@ -3800,6 +5060,10 @@ evaluation(struct_processus *s_etat_proc ((*s_etat_processus).erreur_execution != d_ex) || ((*s_etat_processus).exception != d_ep)) { + // Il est anormal de récupérer ici une erreur + // d'exécution puisqu'on empile une constante + // symbolique. + if (presence_egalite == d_vrai) { liberation(s_etat_processus, s_objet_evalue); @@ -3899,50 +5163,10 @@ evaluation(struct_processus *s_etat_proc (*s_etat_processus).niveau_courant = niveau_initial; - for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++) + if (retrait_variable_par_niveau(s_etat_processus) == d_erreur) { - if ((*s_etat_processus).s_liste_variables[n].niveau - > niveau_initial) - { - m++; - } - } - - registre_variables = (*s_etat_processus).s_liste_variables; - (*s_etat_processus).nombre_variables -= m; - - if (((*s_etat_processus).s_liste_variables = malloc( - (*s_etat_processus).nombre_variables * - sizeof(struct_variable))) == NULL) - { - if (presence_egalite == d_vrai) - { - liberation(s_etat_processus, s_objet_evalue); - } - - (*s_etat_processus).instruction_courante = instruction_courante; - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); } - - for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++) - { - if (registre_variables[n + m].niveau > niveau_initial) - { - free(registre_variables[n + m].nom); - liberation(s_etat_processus, - registre_variables[n + m].objet); - m++; - n--; - } - else - { - (*s_etat_processus).s_liste_variables[n] = - registre_variables[n + m]; - } - } - - free(registre_variables); } /* @@ -4089,16 +5313,27 @@ evaluation(struct_processus *s_etat_proc (*s_etat_processus).instruction_courante = (*((struct_fonction *) (*s_objet).objet)).nom_fonction; + registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai) + ? 'E' : 'N'; + cf(s_etat_processus, 35); + analyse(s_etat_processus, (*((struct_fonction *) (*s_objet).objet)).fonction); - (*s_etat_processus).instruction_courante = instruction_courante; + if (registre_type_evaluation == 'E') + { + sf(s_etat_processus, 35); + } + else + { + cf(s_etat_processus, 35); + } + if (((*s_etat_processus).erreur_systeme != d_es) || ((*s_etat_processus).erreur_execution != d_ex) || ((*s_etat_processus).exception != d_ep)) { - (*s_etat_processus).instruction_courante = instruction_courante; (*s_etat_processus).mode_execution_programme = registre_mode_execution_programme; return(d_erreur); @@ -4106,18 +5341,18 @@ evaluation(struct_processus *s_etat_proc } else { + (*s_etat_processus).instruction_courante = instruction_courante; + if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - (*s_etat_processus).instruction_courante = instruction_courante; return(d_erreur); } if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_objet_tampon) == d_erreur) { - (*s_etat_processus).instruction_courante = instruction_courante; return(d_erreur); } }