rpl/src/evaluation.c - diff

Return to evaluation.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/evaluation.c between versions 1.77 and 1.78

-version 1.77, 2013/04/17 13:53:17
+version 1.78, 2013/04/23 21:26:01
  Line 6721  evaluation(struct_processus *s_etat_proc
                                  }
                                  depilement_pile_systeme(s_etat_processus);
+                                 if ((((*s_etat_processus).erreur_execution !=
+                                         d_ex) || ((*s_etat_processus)
+                                         .erreur_systeme != d_es)) &&
+                                         ((*s_etat_processus).arret_si_exception
+                                         == d_faux))
+                                 {
+                                     // Reprise sur erreur.
+ //==============================================================================
+ //  Réindentation
+ //==============================================================================
+             drapeau_then = d_faux;
+             while(drapeau_then == d_faux)
+             {
+                 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_forall) ||
+                                 TEST(instruction_start) ||
+                                 TEST(instruction_select) ||
+                                 TEST(instruction_case) ||
+                                 TEST(instruction_critical) ||
+                                 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)
+                                 {
+                                     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).exception
+                                         = registre_exception;
+                                 (*s_etat_processus).erreur_execution =
+                                     registre_erreur_execution;
+                             }
+                             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))
+                             {
+                                 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)
+                                 {
+                                     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).exception
+                                         = registre_exception;
+                                 (*s_etat_processus).erreur_execution =
+                                         registre_erreur_execution;
+                             }
+                             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;
+                                         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);
+                                 }
+                             }
+                         }
+                         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;
+             (*s_etat_processus).exception = d_ep;
+             (*s_etat_processus).erreur_execution = d_ex;
+ //==============================================================================
+ //  Fin de la réindentation
+ //==============================================================================
+                                 }
                              }
                              else
                              {

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.77
changed lines
	Added in v.1.78