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

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

version 1.34, 2011/04/14 09:57:15 version 1.70, 2013/03/05 16:20:47
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.13
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 51  evaluation(struct_processus *s_etat_proc Line 51  evaluation(struct_processus *s_etat_proc
   
     logical1                        drapeau_then;      logical1                        drapeau_then;
     logical1                        erreur_evaluation;      logical1                        erreur_evaluation;
       logical1                        presence_compteur;
     logical1                        presence_egalite;      logical1                        presence_egalite;
     logical1                        presence_fonction;      logical1                        presence_fonction;
     logical1                        presence_variable;      logical1                        presence_variable;
Line 94  evaluation(struct_processus *s_etat_proc Line 95  evaluation(struct_processus *s_etat_proc
   
     unsigned long                   k;      unsigned long                   k;
     unsigned long                   l;      unsigned long                   l;
     unsigned long                   n;  
     unsigned long                   niveau_initial;      unsigned long                   niveau_initial;
     unsigned long                   nombre_termes;      unsigned long                   nombre_termes;
     unsigned long                   registre_hauteur_pile_operationnelle;      unsigned long                   registre_hauteur_pile_operationnelle;
Line 180  evaluation(struct_processus *s_etat_proc Line 180  evaluation(struct_processus *s_etat_proc
                     {                      {
                         // Variable partagée                          // Variable partagée
   
                         if (pthread_mutex_lock(&((*(*s_etat_processus)  
                                 .s_liste_variables_partagees).mutex)) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_processus;  
                             return(d_erreur);  
                         }  
   
                         presence_variable_partagee = d_faux;                          presence_variable_partagee = d_faux;
   
                         if (recherche_variable_partagee(s_etat_processus,                          if (recherche_variable_partagee(s_etat_processus,
Line 195  evaluation(struct_processus *s_etat_proc Line 187  evaluation(struct_processus *s_etat_proc
                                 .pointeur_variable_courante).nom,                                  .pointeur_variable_courante).nom,
                                 (*(*s_etat_processus)                                  (*(*s_etat_processus)
                                 .pointeur_variable_courante)                                  .pointeur_variable_courante)
                                 .variable_partagee, 'E') == d_vrai)                                  .variable_partagee, 'E') != NULL)
                         {                          {
                             presence_variable = d_vrai;                              presence_variable = d_vrai;
                             presence_variable_partagee = d_vrai;                              presence_variable_partagee = d_vrai;
   
                             if ((*((*(*s_etat_processus)                              if ((*(*(*s_etat_processus)
                                     .s_liste_variables_partagees).table                                      .pointeur_variable_partagee_courante).objet)
                                     [(*(*s_etat_processus)                                      .type == ADR)
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet)).type  
                                     == ADR)  
                             {                              {
                                 presence_fonction = d_vrai;                                  presence_fonction = d_vrai;
                             }                              }
Line 213  evaluation(struct_processus *s_etat_proc Line 202  evaluation(struct_processus *s_etat_proc
                             if ((s_copie_variable_partagee =                              if ((s_copie_variable_partagee =
                                     copie_objet(s_etat_processus,                                      copie_objet(s_etat_processus,
                                     (*(*s_etat_processus)                                      (*(*s_etat_processus)
                                     .s_liste_variables_partagees)                                      .pointeur_variable_partagee_courante).objet,
                                     .table[(*(*s_etat_processus)                                      'P')) == NULL)
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet, 'P')) == NULL)  
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_allocation_memoire;                                          d_es_allocation_memoire;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 234  evaluation(struct_processus *s_etat_proc Line 221  evaluation(struct_processus *s_etat_proc
                             }                              }
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees).mutex))                                      .pointeur_variable_partagee_courante)
                                     != 0)                                      .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 247  evaluation(struct_processus *s_etat_proc Line 234  evaluation(struct_processus *s_etat_proc
                             (*s_etat_processus).erreur_systeme = d_es;                              (*s_etat_processus).erreur_systeme = d_es;
                             presence_variable = d_faux;                              presence_variable = d_faux;
                             presence_variable_partagee = d_faux;                              presence_variable_partagee = d_faux;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return(d_erreur);  
                             }  
                         }                          }
                     }                      }
                     else                      else
Line 308  evaluation(struct_processus *s_etat_proc Line 287  evaluation(struct_processus *s_etat_proc
                 (*s_etat_processus).autorisation_empilement_programme = 'N';                  (*s_etat_processus).autorisation_empilement_programme = 'N';
   
                 (*(*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;  
   
                 if (presence_variable_partagee == d_faux)                  if (presence_variable_partagee == d_faux)
                 {                  {
                     (*s_etat_processus).position_courante =                      (*s_etat_processus).position_courante =
                             (*((unsigned long *)                              (*((unsigned long *) ((*(*(*s_etat_processus)
                             ((*(*(*s_etat_processus).pointeur_variable_courante)                              .pointeur_variable_courante).objet).objet)));
                             .objet).objet)));  
                 }                  }
                 else                  else
                 {                  {
Line 324  evaluation(struct_processus *s_etat_proc Line 301  evaluation(struct_processus *s_etat_proc
                             (*((unsigned long *) (*s_copie_variable_partagee)                              (*((unsigned long *) (*s_copie_variable_partagee)
                             .objet));                              .objet));
                     liberation(s_etat_processus, s_copie_variable_partagee);                      liberation(s_etat_processus, s_copie_variable_partagee);
   
                     if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                             .s_liste_variables_partagees).mutex)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_processus;  
                         return(d_erreur);  
                     }  
                 }                  }
   
                 if ((*s_etat_processus).profilage == d_vrai)                  if ((*s_etat_processus).profilage == d_vrai)
Line 408  evaluation(struct_processus *s_etat_proc Line 377  evaluation(struct_processus *s_etat_proc
   
                     if ((*s_etat_processus).erreur_systeme != d_es)                      if ((*s_etat_processus).erreur_systeme != d_es)
                     {                      {
                         if (presence_variable_partagee == d_vrai)  
                         {  
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return(d_erreur);  
                             }  
                         }  
   
                         return(d_erreur);                          return(d_erreur);
                     }                      }
                 }                  }
Line 757  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 801  evaluation(struct_processus *s_etat_proc Line 761  evaluation(struct_processus *s_etat_proc
                             ((*s_etat_processus).erreur_systeme == d_es) &&                              ((*s_etat_processus).erreur_systeme == d_es) &&
                             ((*s_etat_processus).exception == d_ep))                              ((*s_etat_processus).exception == d_ep))
                     {                      {
                           registre_evaluation_expression_compilee =
                                   (*s_etat_processus)
                                   .evaluation_expression_compilee;
   
                           if (((*(*s_etat_processus).pointeur_variable_courante)
                                   .origine == 'E') && ((*(*s_etat_processus)
                                   .pointeur_variable_courante).niveau == 0))
                           {
                               (*s_etat_processus).evaluation_expression_compilee
                                       = 'Y';
                           }
                           else
                           {
                               (*s_etat_processus).evaluation_expression_compilee
                                       = 'N';
                           }
   
                         analyse(s_etat_processus, (*((struct_fonction *)                          analyse(s_etat_processus, (*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .fonction);                                  .fonction);
   
                           (*s_etat_processus).evaluation_expression_compilee =
                                   registre_evaluation_expression_compilee;
   
                         if (type_evaluation == 'I')                          if (type_evaluation == 'I')
                         {                          {
                             (*s_etat_processus).derniere_erreur_evaluation =                              (*s_etat_processus).derniere_erreur_evaluation =
Line 822  evaluation(struct_processus *s_etat_proc Line 802  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 912  evaluation(struct_processus *s_etat_proc Line 892  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 932  evaluation(struct_processus *s_etat_proc Line 914  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 944  evaluation(struct_processus *s_etat_proc Line 934  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 987  evaluation(struct_processus *s_etat_proc Line 1005  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 999  evaluation(struct_processus *s_etat_proc Line 1025  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 1084  evaluation(struct_processus *s_etat_proc Line 1284  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1097  evaluation(struct_processus *s_etat_proc Line 1299  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 1139  evaluation(struct_processus *s_etat_proc Line 1377  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
                                             }                                              }
Line 1237  evaluation(struct_processus *s_etat_proc Line 1661  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1250  evaluation(struct_processus *s_etat_proc Line 1676  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 1292  evaluation(struct_processus *s_etat_proc Line 1754  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1306  evaluation(struct_processus *s_etat_proc Line 1776  evaluation(struct_processus *s_etat_proc
                                                     break;                                                      break;
                                                 }                                                  }
                                             }                                              }
                                               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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 1349  evaluation(struct_processus *s_etat_proc Line 1996  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Line 1663  evaluation(struct_processus *s_etat_proc Line 2310  evaluation(struct_processus *s_etat_proc
                     if ((*(*s_etat_processus).pointeur_variable_courante).objet                      if ((*(*s_etat_processus).pointeur_variable_courante).objet
                             == NULL)                              == NULL)
                     {                      {
                         if (pthread_mutex_lock(&((*(*s_etat_processus)  
                                 .s_liste_variables_partagees).mutex)) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_processus;  
                         }  
   
                         if (recherche_variable_partagee(s_etat_processus,                          if (recherche_variable_partagee(s_etat_processus,
                                 (*(*s_etat_processus)                                  (*(*s_etat_processus)
                                 .pointeur_variable_courante).nom,                                  .pointeur_variable_courante).nom,
                                 (*(*s_etat_processus)                                  (*(*s_etat_processus)
                                 .pointeur_variable_courante).variable_partagee,                                  .pointeur_variable_courante).variable_partagee,
                                 'E') == d_vrai)                                  'E') != NULL)
                         {                          {
                             // Une variable partagée existe.                              // Une variable partagée existe.
   
Line 1683  evaluation(struct_processus *s_etat_proc Line 2323  evaluation(struct_processus *s_etat_proc
   
                             (*(*s_etat_processus).pointeur_variable_courante)                              (*(*s_etat_processus).pointeur_variable_courante)
                                     .objet = (*(*s_etat_processus)                                      .objet = (*(*s_etat_processus)
                                     .s_liste_variables_partagees).table                                      .pointeur_variable_partagee_courante)
                                     [(*(*s_etat_processus)                                      .objet;
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet;  
                         }                          }
                         else                          else
                         {                          {
                             presence_variable_partagee = d_faux;                              presence_variable_partagee = d_faux;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                             }  
                         }                          }
                     }                      }
                     else                      else
Line 1727  evaluation(struct_processus *s_etat_proc Line 2358  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1761  evaluation(struct_processus *s_etat_proc Line 2392  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1783  evaluation(struct_processus *s_etat_proc Line 2414  evaluation(struct_processus *s_etat_proc
                             return(d_erreur);                              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);                              liberation(s_etat_processus, s_objet_indice_i);
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
Line 1795  evaluation(struct_processus *s_etat_proc Line 2426  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1835  evaluation(struct_processus *s_etat_proc Line 2466  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1878  evaluation(struct_processus *s_etat_proc Line 2509  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 1915  evaluation(struct_processus *s_etat_proc Line 2546  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 1958  evaluation(struct_processus *s_etat_proc Line 2589  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2021  evaluation(struct_processus *s_etat_proc Line 2652  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2057  evaluation(struct_processus *s_etat_proc Line 2688  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2094  evaluation(struct_processus *s_etat_proc Line 2725  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2130  evaluation(struct_processus *s_etat_proc Line 2761  evaluation(struct_processus *s_etat_proc
                                 .pointeur_variable_courante).objet)).objet))                                  .pointeur_variable_courante).objet)).objet))
                                 .nombre_colonnes))                                  .nombre_colonnes))
                         {                          {
                             liberation(s_etat_processus, s_objet_indice_i);  
                             liberation(s_etat_processus, s_objet_indice_j);  
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
   
                             if (presence_variable_partagee == d_vrai)                              if (presence_variable_partagee == d_vrai)
Line 2142  evaluation(struct_processus *s_etat_proc Line 2771  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2178  evaluation(struct_processus *s_etat_proc Line 2807  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2221  evaluation(struct_processus *s_etat_proc Line 2850  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2264  evaluation(struct_processus *s_etat_proc Line 2893  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2327  evaluation(struct_processus *s_etat_proc Line 2956  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2362  evaluation(struct_processus *s_etat_proc Line 2991  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2415  evaluation(struct_processus *s_etat_proc Line 3044  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2451  evaluation(struct_processus *s_etat_proc Line 3080  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2477  evaluation(struct_processus *s_etat_proc Line 3106  evaluation(struct_processus *s_etat_proc
                      */                       */
   
                     else if (((*((*(*s_etat_processus)                      else if (((*((*(*s_etat_processus)
                             .pointeur_variable_courante).objet)).type == TAB) &&                              .pointeur_variable_courante).objet)).type == TBL) &&
                             ((*((struct_fonction *) (*(*l_element_courant)                              ((*((struct_fonction *) (*(*l_element_courant)
                             .donnee).objet)).nombre_arguments == 1))                              .donnee).objet)).nombre_arguments == 1))
                     {                      {
Line 2494  evaluation(struct_processus *s_etat_proc Line 3123  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2529  evaluation(struct_processus *s_etat_proc Line 3158  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2570  evaluation(struct_processus *s_etat_proc Line 3199  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2608  evaluation(struct_processus *s_etat_proc Line 3237  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2665  evaluation(struct_processus *s_etat_proc Line 3294  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2702  evaluation(struct_processus *s_etat_proc Line 3331  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2744  evaluation(struct_processus *s_etat_proc Line 3373  evaluation(struct_processus *s_etat_proc
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2796  evaluation(struct_processus *s_etat_proc Line 3425  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2828  evaluation(struct_processus *s_etat_proc Line 3457  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2865  evaluation(struct_processus *s_etat_proc Line 3494  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2900  evaluation(struct_processus *s_etat_proc Line 3529  evaluation(struct_processus *s_etat_proc
                                         NULL;                                          NULL;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 2931  evaluation(struct_processus *s_etat_proc Line 3560  evaluation(struct_processus *s_etat_proc
                                     NULL;                                      NULL;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees) .mutex)) != 0)                                      .pointeur_variable_partagee_courante)
                                       .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 2963  evaluation(struct_processus *s_etat_proc Line 3593  evaluation(struct_processus *s_etat_proc
                                     NULL;                                      NULL;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees).mutex)) != 0)                                      .pointeur_variable_partagee_courante)
                                       .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 2986  evaluation(struct_processus *s_etat_proc Line 3617  evaluation(struct_processus *s_etat_proc
                                 .pointeur_variable_courante).objet = NULL;                                  .pointeur_variable_courante).objet = NULL;
   
                         if (pthread_mutex_unlock(&((*(*s_etat_processus)                          if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                 .s_liste_variables_partagees).mutex)) != 0)                                  .pointeur_variable_partagee_courante).mutex))
                                   != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_processus;                                      d_es_processus;
Line 3148  evaluation(struct_processus *s_etat_proc Line 3780  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 3237  evaluation(struct_processus *s_etat_proc Line 3869  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3257  evaluation(struct_processus *s_etat_proc Line 3891  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3269  evaluation(struct_processus *s_etat_proc Line 3911  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 3312  evaluation(struct_processus *s_etat_proc Line 3982  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3324  evaluation(struct_processus *s_etat_proc Line 4002  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3447  evaluation(struct_processus *s_etat_proc Line 4302  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3460  evaluation(struct_processus *s_etat_proc Line 4317  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .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)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 3502  evaluation(struct_processus *s_etat_proc Line 4395  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .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)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3597  evaluation(struct_processus *s_etat_proc Line 4675  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3610  evaluation(struct_processus *s_etat_proc Line 4690  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .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)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 3652  evaluation(struct_processus *s_etat_proc Line 4768  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3701  evaluation(struct_processus *s_etat_proc Line 5002  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Line 3729  evaluation(struct_processus *s_etat_proc Line 5030  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 3818  evaluation(struct_processus *s_etat_proc Line 5119  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3838  evaluation(struct_processus *s_etat_proc Line 5141  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3850  evaluation(struct_processus *s_etat_proc Line 5161  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 3893  evaluation(struct_processus *s_etat_proc Line 5232  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3905  evaluation(struct_processus *s_etat_proc Line 5252  evaluation(struct_processus *s_etat_proc
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_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                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4028  evaluation(struct_processus *s_etat_proc Line 5552  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 4041  evaluation(struct_processus *s_etat_proc Line 5567  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 4083  evaluation(struct_processus *s_etat_proc Line 5645  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                             else                                              else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                             {                                              {
                                                 depilement_pile_systeme(                                                  /*
                                                         s_etat_processus);                                                   * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                 if ((*s_etat_processus)                                                  presence_compteur =
                                                         .erreur_systeme != d_es)                                                      (((*(*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 ==                                                      if (presence_egalite ==
                                                             d_vrai)                                                              d_vrai)
                                                     {                                                      {
Line 4110  evaluation(struct_processus *s_etat_proc Line 5702  evaluation(struct_processus *s_etat_proc
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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;                                                  if (presence_compteur == d_vrai)
                             (*s_etat_processus).erreur_execution = d_ex;                                                  {
                                                       if (recherche_variable(
                             erreur_evaluation = d_erreur;                                                          s_etat_processus,
                         }                                                          (*(*s_etat_processus)
                         else                                                          .l_base_pile_systeme)
                         {                                                          .nom_variable) ==
                             // On ne détruit pas les variables pour les inclure                                                          d_faux)
                             // dans le fichier rpl-core.                                                      {
                                                           (*s_etat_processus)
                             (*s_etat_processus).gel_liste_variables = d_vrai;                                                  .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                             registre_erreur_execution =                                                  .erreur_execution =
                                     (*s_etat_processus).erreur_execution;                                                  d_ex_erreur_traitement_boucle;
                             registre_exception =  
                                     (*s_etat_processus).exception;                                                          if (presence_egalite ==
                             registre_erreur_systeme =                                                                  d_vrai)
                                     (*s_etat_processus).erreur_systeme;                                                          {
                                                               liberation(
                             (*s_etat_processus).s_objet_errone = s_objet;                                                              s_etat_processus,
                             (*s_etat_processus).s_objet_erreur =                                                              s_objet_evalue);
                                     (*l_element_courant).donnee;                                                          }
   
                             l_element_courant = (*l_element_courant).suivant;                                                          (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                             while(l_element_courant != NULL)                                                      if ((*(*s_etat_processus)
                             {                                                      .pointeur_variable_courante)
                                 if ((*(*l_element_courant).donnee).type == FCT)                                                      .objet == NULL)
                                 {                                                      {
                                     (*s_etat_processus).instruction_courante =                                                          (*s_etat_processus)
                                             (*((struct_fonction *)                                                          .erreur_systeme = d_es;
                                             (*(*l_element_courant).donnee)                                                          (*s_etat_processus)
                                             .objet)).nom_fonction;                                                          .erreur_execution =
                                     fonction = (*((struct_fonction *)                                                          d_ex_variable_partagee;
                                             (*(*l_element_courant).donnee)  
                                             .objet)).fonction;                                                          if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                     if (recherche_variable(s_etat_processus,                                                          (*s_etat_processus)
                                             (*s_etat_processus)                                                          .instruction_courante =
                                             .instruction_courante) == d_faux)                                                          instruction_courante;
                                     {                                                          return(d_erreur);
                                         (*s_etat_processus).erreur_systeme                                                      }
                                                 = d_es;  
   
                                         /*                                                      (*s_etat_processus)
                                          * Traitement de la pile système par les                                                          .niveau_courant--;
                                          * différentes instructions.  
                                          */  
   
                                         if (TEST(instruction_if) ||                                                      if (
                                                 TEST(instruction_iferr) ||                                                  retrait_variables_par_niveau(
                                                 TEST(instruction_do) ||                                                  s_etat_processus) == d_erreur)
                                                 TEST(instruction_while) ||                                                      {
                                                 TEST(instruction_for) ||                                                          if (presence_egalite ==
                                                 TEST(instruction_start) ||                                                                  d_vrai)
                                                 TEST(instruction_select) ||                                                          {
                                                 TEST(instruction_case) ||                                                              liberation(
                                                 TEST(vers_niveau_superieur))                                                              s_etat_processus,
                                         {                                                              s_objet_evalue);
                                             if (TEST(vers_niveau_superieur))                                                          }
                                             {  
                                                 analyse(s_etat_processus,  
                                                         vers_niveau_superieur);  
   
                                                 if ((*s_etat_processus)                                                          (*s_etat_processus)
                                                         .erreur_systeme != d_es)  
                                                 {  
                                                     (*s_etat_processus)  
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                          return(d_erreur);
                                                       }
                                                 }                                                  }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                             }                                              }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  // Traitement spécifique pour la
                                                         s_etat_processus);                                                  // fin d'une section critique
   
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .l_base_pile_systeme ==
                                                           NULL)
                                                 {                                                  {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                     if (presence_egalite ==                                                      if (presence_egalite ==
                                                             d_vrai)                                                              d_vrai)
                                                     {                                                      {
Line 4218  evaluation(struct_processus *s_etat_proc Line 5807  evaluation(struct_processus *s_etat_proc
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      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)                                                  if ((*(*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                 {                                                  {
                                                     (*s_etat_processus)                                                      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 =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                          return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                 }                                                  }
                                             }  
                                             else  
                                             {  
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4282  evaluation(struct_processus *s_etat_proc Line 5879  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Line 4364  evaluation(struct_processus *s_etat_proc Line 5961  evaluation(struct_processus *s_etat_proc
                             {                              {
                                 // Variable partagée                                  // Variable partagée
   
                                 if (pthread_mutex_lock(&((*(*s_etat_processus)  
                                         .s_liste_variables_partagees).mutex))  
                                         != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return(d_erreur);  
                                 }  
   
                                 presence_variable_partagee = d_faux;                                  presence_variable_partagee = d_faux;
   
                                 if (recherche_variable_partagee(                                  if (recherche_variable_partagee(
Line 4380  evaluation(struct_processus *s_etat_proc Line 5968  evaluation(struct_processus *s_etat_proc
                                         .pointeur_variable_courante).nom,                                          .pointeur_variable_courante).nom,
                                         (*(*s_etat_processus)                                          (*(*s_etat_processus)
                                         .pointeur_variable_courante)                                          .pointeur_variable_courante)
                                         .variable_partagee, 'E') == d_vrai)                                          .variable_partagee, 'E') != NULL)
                                 {                                  {
                                     presence_variable = d_vrai;                                      presence_variable = d_vrai;
                                     presence_variable_partagee = d_vrai;                                      presence_variable_partagee = d_vrai;
   
                                     if ((*((*(*s_etat_processus)                                      if ((*(*(*s_etat_processus)
                                             .s_liste_variables_partagees).table                                              .pointeur_variable_partagee_courante
                                             [(*(*s_etat_processus)                                              ).objet).type == ADR)
                                             .s_liste_variables_partagees)  
                                             .position_variable].objet)).type  
                                             == ADR)  
                                     {                                      {
                                         presence_fonction = d_vrai;                                          presence_fonction = d_vrai;
                                     }                                      }
Line 4401  evaluation(struct_processus *s_etat_proc Line 5986  evaluation(struct_processus *s_etat_proc
                                             .objet)).symbole == d_faux))                                              .objet)).symbole == d_faux))
                                     {                                      {
                                         if ((s_copie_variable_partagee =                                          if ((s_copie_variable_partagee =
                                                 copie_objet(s_etat_processus,                                              copie_objet(s_etat_processus,
                                                 (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                                 .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                                 .table[(*(*s_etat_processus)                                              ).objet, 'P')) == NULL)
                                                 .s_liste_variables_partagees)  
                                                 .position_variable].objet, 'P'))  
                                                 == NULL)  
                                         {                                          {
                                             if (pthread_mutex_unlock(                                              if (pthread_mutex_unlock(
                                                     &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                                     .s_liste_variables_partagees                                              .pointeur_variable_partagee_courante
                                                     ).mutex)) != 0)                                              ).mutex)) != 0)
                                             {                                              {
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
                                                         .erreur_systeme =                                                          .erreur_systeme =
Line 4428  evaluation(struct_processus *s_etat_proc Line 6010  evaluation(struct_processus *s_etat_proc
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 4441  evaluation(struct_processus *s_etat_proc Line 6023  evaluation(struct_processus *s_etat_proc
                                     (*s_etat_processus).erreur_systeme = d_es;                                      (*s_etat_processus).erreur_systeme = d_es;
                                     presence_variable = d_faux;                                      presence_variable = d_faux;
                                     presence_variable_partagee = d_faux;                                      presence_variable_partagee = d_faux;
   
                                     if (pthread_mutex_unlock(  
                                             &((*(*s_etat_processus)  
                                             .s_liste_variables_partagees)  
                                             .mutex)) != 0)  
                                     {  
                                         (*s_etat_processus).erreur_systeme =  
                                                 d_es_processus;  
                                         return(d_erreur);  
                                     }  
                                 }                                  }
                             }                              }
                             else                              else
Line 4601  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 4736  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 4756  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 4786  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
                             {                              {
Line 4910  evaluation(struct_processus *s_etat_proc Line 6468  evaluation(struct_processus *s_etat_proc
                                 {                                  {
                                     // Variable partagée                                      // Variable partagée
   
                                     if (pthread_mutex_lock(  
                                             &((*(*s_etat_processus)  
                                             .s_liste_variables_partagees)  
                                             .mutex)) != 0)  
                                     {  
                                         (*s_etat_processus).erreur_systeme =  
                                                 d_es_processus;  
                                         return(d_erreur);  
                                     }  
   
                                     if (recherche_variable_partagee(                                      if (recherche_variable_partagee(
                                             s_etat_processus,                                              s_etat_processus,
                                             (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                             .pointeur_variable_courante).nom,                                              .pointeur_variable_courante).nom,
                                             (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                             .pointeur_variable_courante)                                              .pointeur_variable_courante)
                                             .variable_partagee, 'E') == d_vrai)                                              .variable_partagee, 'E') != NULL)
                                     {                                      {
                                         liberation(s_etat_processus,                                          liberation(s_etat_processus,
                                                 s_objet_elementaire);                                                  s_objet_elementaire);
   
                                         if ((s_objet_elementaire =                                          if ((s_objet_elementaire =
                                                 copie_objet(s_etat_processus,                                              copie_objet(s_etat_processus,
                                                 (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                                 .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                                 .table[(*(*s_etat_processus)                                              ).objet, 'P')) == NULL)
                                                 .s_liste_variables_partagees)  
                                                 .position_variable].objet,  
                                                 'P')) == NULL)  
                                         {                                          {
                                             if (pthread_mutex_unlock(                                              if (pthread_mutex_unlock(
                                                     &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                                     .s_liste_variables_partagees                                              .pointeur_variable_partagee_courante
                                                     ).mutex)) != 0)                                              ).mutex)) != 0)
                                             {                                              {
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
                                                         .erreur_systeme =                                                          .erreur_systeme =
Line 4964  evaluation(struct_processus *s_etat_proc Line 6509  evaluation(struct_processus *s_etat_proc
                                                     instruction_courante;                                                      instruction_courante;
                                             return(d_erreur);                                              return(d_erreur);
                                         }                                          }
                                     }  
   
                                     if (pthread_mutex_unlock(                                          if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                          {
                                         (*s_etat_processus).erreur_systeme =                                              (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                      d_es_processus;
                                         return(d_erreur);                                              return(d_erreur);
                                           }
                                     }                                      }
                                 }                                  }
                                 else                                  else
Line 5113  evaluation(struct_processus *s_etat_proc Line 6658  evaluation(struct_processus *s_etat_proc
   
             // Traitement de l'instruction EXIT en mode interactif              // Traitement de l'instruction EXIT en mode interactif
   
             if (l_element_courant != NULL)  
             {  
                 l_element_courant = (*l_element_courant).suivant;  
             }  
             else  
             {  
                 (*s_etat_processus).mode_execution_programme = 'Y';  
   
                 if ((*s_etat_processus).niveau_courant == 1)  
                 {  
                     (*s_etat_processus).debug_programme = d_faux;  
                     (*s_etat_processus).execution_pas_suivant = d_vrai;  
                 }  
             }  
   
             if ((*s_etat_processus).traitement_cycle_exit != 'N')              if ((*s_etat_processus).traitement_cycle_exit != 'N')
             {              {
                 registre_expression_courante =                  registre_expression_courante =
Line 5154  evaluation(struct_processus *s_etat_proc Line 6684  evaluation(struct_processus *s_etat_proc
                 (*s_etat_processus).expression_courante =                  (*s_etat_processus).expression_courante =
                         registre_expression_courante;                          registre_expression_courante;
             }              }
   
               if (l_element_courant != NULL)
               {
                   l_element_courant = (*l_element_courant).suivant;
               }
               else
               {
                   (*s_etat_processus).mode_execution_programme = 'Y';
   
                   if ((*s_etat_processus).niveau_courant == 1)
                   {
                       (*s_etat_processus).debug_programme = d_faux;
                       (*s_etat_processus).execution_pas_suivant = d_vrai;
                   }
               }
   
         }          }
   
         if (niveau_initial < (*s_etat_processus).niveau_courant)          if (niveau_initial < (*s_etat_processus).niveau_courant)
Line 5165  evaluation(struct_processus *s_etat_proc Line 6711  evaluation(struct_processus *s_etat_proc
   
             (*s_etat_processus).niveau_courant = niveau_initial;              (*s_etat_processus).niveau_courant = niveau_initial;
   
             if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)              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;
                   (*s_etat_processus).mode_execution_programme =
                           registre_mode_execution_programme;
                 return(d_erreur);                  return(d_erreur);
             }              }
         }          }
Line 5175  evaluation(struct_processus *s_etat_proc Line 6730  evaluation(struct_processus *s_etat_proc
          * Retrait des variables statiques créées dans l'expression           * Retrait des variables statiques créées dans l'expression
          */           */
   
         for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)          if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
         {          {
             if ((*s_etat_processus).s_liste_variables_statiques[n]              if (presence_egalite == d_vrai)
                     .niveau > (*s_etat_processus).niveau_courant)  
             {              {
                 if (retrait_variable_statique(s_etat_processus,                  liberation(s_etat_processus, s_objet_evalue);
                         (*s_etat_processus).s_liste_variables_statiques[n].nom,  
                         (*s_etat_processus).s_liste_variables_statiques[n]  
                         .variable_statique) == d_erreur)  
                 {  
                     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).instruction_courante =
                       instruction_courante;
               (*s_etat_processus).mode_execution_programme =
                       registre_mode_execution_programme;
               return(d_erreur);
         }          }
   
         /*          /*
          * Retrait des variables partagées créées dans l'expression           * Retrait des variables partagées créées dans l'expression
          */           */
   
         if (pthread_mutex_lock(&((*(*s_etat_processus)          if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
                 .s_liste_variables_partagees).mutex)) != 0)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              if (presence_egalite == d_vrai)
             return(d_erreur);  
         }  
   
         for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)  
                 .nombre_variables; n++)  
         {  
             if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]  
                     .niveau > (*s_etat_processus).niveau_courant)  
             {              {
                 if (retrait_variable_partagee(s_etat_processus,                  liberation(s_etat_processus, s_objet_evalue);
                         (*(*s_etat_processus).s_liste_variables_partagees)  
                         .table[n].nom, (*(*s_etat_processus)  
                         .s_liste_variables_partagees).table[n]  
                         .variable_partagee) == d_erreur)  
                 {  
                     if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                             .s_liste_variables_partagees).mutex)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return(d_erreur);  
                     }  
   
                     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);  
                 }  
             }              }
         }  
   
         if (pthread_mutex_unlock(&((*(*s_etat_processus)              (*s_etat_processus).instruction_courante =
                 .s_liste_variables_partagees).mutex)) != 0)                      instruction_courante;
         {              (*s_etat_processus).mode_execution_programme =
             (*s_etat_processus).erreur_systeme = d_es_processus;                      registre_mode_execution_programme;
             return(d_erreur);              return(d_erreur);
         }          }
   
Removed from v.1.34  
changed lines
  Added in v.1.70

CVSweb interface <joel.bertrand@systella.fr>