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.71 and 1.72

-version 1.71, 2013/03/05 16:26:46
+version 1.72, 2013/03/05 21:02:35
  Line 98  evaluation(struct_processus *s_etat_proc
      unsigned long                   niveau_initial;
      unsigned long                   nombre_termes;
      unsigned long                   registre_hauteur_pile_operationnelle;
-     unsigned long                   registre_niveau_courant;
      unsigned long                   registre_position_courante;
      void                            (*fonction)();
- Line 5867  evaluation(struct_processus *s_etat_proc
+ Line 5866  evaluation(struct_processus *s_etat_proc
                              (*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_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)
                              {
                                  liberation(s_etat_processus, s_objet_evalue);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.71
changed lines
	Added in v.1.72