[BACK]Return to evaluation.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/evaluation.c between versions 1.69 and 1.70

version 1.69, 2013/02/27 17:11:40 version 1.70, 2013/03/05 16:20:47
Line 715  evaluation(struct_processus *s_etat_proc Line 715  evaluation(struct_processus *s_etat_proc
         registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)          registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
                 .retour_definition;                  .retour_definition;
         (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';          (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
           /*
         (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =          (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
                 s_objet;                  s_objet;
                   */
   
         l_element_courant = (struct_liste_chainee *) (*s_objet).objet;          l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
         autorisation_empilement_programme = (*s_etat_processus)          autorisation_empilement_programme = (*s_etat_processus)
Line 5869  evaluation(struct_processus *s_etat_proc Line 5871  evaluation(struct_processus *s_etat_proc
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
   
                             (*s_etat_processus).exception = d_ep;  
                             (*s_etat_processus).erreur_execution = d_ex;  
   
                             erreur_evaluation = d_erreur;  
                         }  
                         else  
                         {  
                             // On ne détruit pas les variables pour les inclure  
                             // dans le fichier rpl-core.  
   
                             (*s_etat_processus).gel_liste_variables = d_vrai;  
   
                             registre_erreur_execution =  
                                     (*s_etat_processus).erreur_execution;  
                             registre_exception =  
                                     (*s_etat_processus).exception;  
                             registre_erreur_systeme =  
                                     (*s_etat_processus).erreur_systeme;  
   
                             (*s_etat_processus).s_objet_errone = s_objet;  
                             (*s_etat_processus).s_objet_erreur =  
                                     (*l_element_courant).donnee;  
   
                             l_element_courant = (*l_element_courant).suivant;  
   
                             while(l_element_courant != NULL)  
                             {  
                                 if ((*(*l_element_courant).donnee).type == FCT)  
                                 {  
                                     (*s_etat_processus).instruction_courante =  
                                             (*((struct_fonction *)  
                                             (*(*l_element_courant).donnee)  
                                             .objet)).nom_fonction;  
                                     fonction = (*((struct_fonction *)  
                                             (*(*l_element_courant).donnee)  
                                             .objet)).fonction;  
   
                                     if (recherche_variable(s_etat_processus,  
                                             (*s_etat_processus)  
                                             .instruction_courante) == d_faux)  
                                     {  
                                         (*s_etat_processus).erreur_systeme  
                                                 = d_es;  
   
                                         /*  
                                          * Traitement de la pile système par les  
                                          * différentes instructions.  
                                          */  
   
                                         if (TEST(instruction_if) ||  
                                                 TEST(instruction_iferr) ||  
                                                 TEST(instruction_do) ||  
                                                 TEST(instruction_while) ||  
                                                 TEST(instruction_for) ||  
                                                 TEST(instruction_forall) ||  
                                                 TEST(instruction_start) ||  
                                                 TEST(instruction_select) ||  
                                                 TEST(instruction_case) ||  
                                                 TEST(instruction_critical) ||  
                                                 TEST(vers_niveau_superieur))  
                                         {  
                                             if (TEST(vers_niveau_superieur))  
                                             {  
                                                 analyse(s_etat_processus,  
                                                         vers_niveau_superieur);  
   
                                                 if ((*s_etat_processus)  
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
                                             }  
                                             else if (TEST(instruction_for) ||  
                                                     TEST(instruction_forall) ||  
                                                     TEST(instruction_start))  
                                             {  
                                                 empilement_pile_systeme(  
                                                         s_etat_processus);  
   
                                                 if ((*s_etat_processus)  
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
   
                                                 (*(*s_etat_processus)  
                                                         .l_base_pile_systeme)  
                                                         .type_cloture = 'L';  
                                             }  
                                             else  
                                             {  
                                                 empilement_pile_systeme(  
                                                         s_etat_processus);  
   
                                                 if ((*s_etat_processus)  
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
                                             }  
                                         }  
                                         else if (TEST(instruction_end) ||  
                                                 TEST(instruction_next) ||  
                                                 TEST(instruction_step) ||  
                                                 TEST(vers_niveau_inferieur))  
                                         {  
                                             if (TEST(vers_niveau_inferieur))  
                                             {  
                                                 analyse(s_etat_processus,  
                                                         vers_niveau_inferieur);  
   
                                                 if ((*s_etat_processus)  
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
                                             }  
                                             else if ((TEST(instruction_next) ||  
                                                     TEST(instruction_step)) &&  
                                                     ((*(*s_etat_processus)  
                                                     .l_base_pile_systeme)  
                                                     .type_cloture != 'L'))  
                                             {  
                                                 /*  
                                                  * Libération des compteurs  
                                                  * de boucle  
                                                  */  
   
                                                 presence_compteur =  
                                                     (((*(*s_etat_processus)  
                                                     .l_base_pile_systeme)  
                                                     .type_cloture == 'F') ||  
                                                     ((*(*s_etat_processus)  
                                                     .l_base_pile_systeme)  
                                                     .type_cloture == 'A'))  
                                                     ? d_vrai : d_faux;  
   
                                                 if (((*(*s_etat_processus)  
                                                     .l_base_pile_systeme)  
                                                     .type_cloture != 'S') &&  
                                                     (presence_compteur ==  
                                                     d_faux))  
                                                 {  
                                                     (*s_etat_processus)  
                                                 .erreur_execution =  
                                                 d_ex_erreur_traitement_boucle;  
   
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
   
                                                 if (presence_compteur == d_vrai)  
                                                 {  
                                                     if (recherche_variable(  
                                                         s_etat_processus,  
                                                         (*(*s_etat_processus)  
                                                         .l_base_pile_systeme)  
                                                         .nom_variable) ==  
                                                         d_faux)  
                                                     {  
                                                         (*s_etat_processus)  
                                                 .erreur_systeme = d_es;  
                                                         (*s_etat_processus)  
                                                 .erreur_execution =  
                                                 d_ex_erreur_traitement_boucle;  
   
                                                         if (presence_egalite ==  
                                                                 d_vrai)  
                                                         {  
                                                             liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                         }  
   
                                                         (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                         return(d_erreur);  
                                                     }  
   
                                                     if ((*(*s_etat_processus)  
                                                     .pointeur_variable_courante)  
                                                     .objet == NULL)  
                                                     {  
                                                         (*s_etat_processus)  
                                                         .erreur_systeme = d_es;  
                                                         (*s_etat_processus)  
                                                         .erreur_execution =  
                                                         d_ex_variable_partagee;  
   
                                                         if (presence_egalite ==  
                                                                 d_vrai)  
                                                         {  
                                                             liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                         }  
   
                                                         (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                         return(d_erreur);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .niveau_courant--;  
   
                                                     if (  
                                                 retrait_variables_par_niveau(  
                                                 s_etat_processus) == d_erreur)  
                                                     {  
                                                         if (presence_egalite ==  
                                                                 d_vrai)  
                                                         {  
                                                             liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                         }  
   
                                                         (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                         return(d_erreur);  
                                                     }  
                                                 }  
   
                                                 depilement_pile_systeme(  
                                                         s_etat_processus);  
                                             }  
                                             else  
                                             {  
                                                 // Traitement spécifique pour la  
                                                 // fin d'une section critique  
   
                                                 if ((*s_etat_processus)  
                                                         .l_base_pile_systeme ==  
                                                         NULL)  
                                                 {  
                                                     (*s_etat_processus)  
                                                         .erreur_systeme =  
                                                         d_es_end_incoherent;  
   
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
   
                                                 if ((*(*s_etat_processus)  
                                                         .l_base_pile_systeme)  
                                                         .type_cloture == 'Q')  
                                                 {  
                                                     if (pthread_mutex_unlock(  
                                                     &mutex_sections_critiques)  
                                                     != 0)  
                                                     {  
                                                         (*s_etat_processus)  
                                                         .erreur_systeme =  
                                                         d_es_processus;  
   
                                                         if (presence_egalite ==  
                                                                 d_vrai)  
                                                         {  
                                                             liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                         }  
   
                                                         (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                         return(d_erreur);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .sections_critiques--;  
                                                 }  
   
                                                 depilement_pile_systeme(  
                                                         s_etat_processus);  
   
                                                 if ((*s_etat_processus)  
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     if (presence_egalite ==  
                                                             d_vrai)  
                                                     {  
                                                         liberation(  
                                                             s_etat_processus,  
                                                             s_objet_evalue);  
                                                     }  
   
                                                     (*s_etat_processus)  
                                                         .instruction_courante =  
                                                         instruction_courante;  
                                                     return(d_erreur);  
                                                 }  
                                             }  
                                         }  
                                     }  
                                 }  
   
                                 l_element_courant =  
                                         (*l_element_courant).suivant;  
                             }  
   
                             (*s_etat_processus).mode_execution_programme =  
                                     registre_mode_execution_programme;  
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
   
                             if (presence_egalite == d_vrai)                              if (presence_egalite == d_vrai)
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
Line 6544  evaluation(struct_processus *s_etat_proc Line 6173  evaluation(struct_processus *s_etat_proc
                             }                              }
   
                             (*s_etat_processus).evaluation_forcee =                              (*s_etat_processus).evaluation_forcee =
                                 registre_evaluation_forcee;                                      registre_evaluation_forcee;
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             (*s_etat_processus).mode_execution_programme = 'N';                              (*s_etat_processus).mode_execution_programme = 'N';
Line 6679  evaluation(struct_processus *s_etat_proc Line 6308  evaluation(struct_processus *s_etat_proc
                                     }                                      }
                                 }                                  }
   
                                 registre_niveau_courant = (*(*s_etat_processus)                                  empilement_pile_systeme(s_etat_processus);
                                         .l_base_pile_systeme).niveau_courant;  
                                 registre_retour_definition =  
                                         (*(*s_etat_processus)  
                                         .l_base_pile_systeme).retour_definition;  
   
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .retour_definition = 'Y';                                          .retour_definition = 'Y';
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant = (*s_etat_processus)                                          .niveau_courant = (*s_etat_processus)
                                         .niveau_courant;                                          .niveau_courant;
                                 empilement_pile_systeme(s_etat_processus);                                  (*(*s_etat_processus).l_base_pile_systeme)
                                           .pointeur_objet_retour =
                                           l_element_courant;
                                   (*(*s_etat_processus).l_base_pile_systeme)
                                           .origine_routine_evaluation = 'Y';
   
                                 if (evaluation(s_etat_processus,                                  if (evaluation(s_etat_processus,
                                         (*(*s_etat_processus)                                          (*(*s_etat_processus)
Line 6699  evaluation(struct_processus *s_etat_proc Line 6328  evaluation(struct_processus *s_etat_proc
                                 {                                  {
                                     depilement_pile_systeme(s_etat_processus);                                      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;  
   
                                     if ((*s_etat_processus).profilage == d_vrai)                                      if ((*s_etat_processus).profilage == d_vrai)
                                     {                                      {
                                         profilage(s_etat_processus, NULL);                                          profilage(s_etat_processus, NULL);
Line 6729  evaluation(struct_processus *s_etat_proc Line 6351  evaluation(struct_processus *s_etat_proc
                                 }                                  }
   
                                 depilement_pile_systeme(s_etat_processus);                                  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;  
                             }                              }
                             else                              else
                             {                              {
Removed from v.1.69  
changed lines
  Added in v.1.70

CVSweb interface <joel.bertrand@systella.fr>