rpl/src/evaluation.c - diff

Return to evaluation.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/evaluation.c between versions 1.31 and 1.99

-version 1.31, 2011/01/03 12:08:03
+version 1.99, 2016/03/09 08:55:27
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.0.20
+   RPL/2 (R) version 4.1.25
-   Copyright (C) 1989-2011 Dr. BERTRAND Joël
+   Copyright (C) 1989-2016 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 48  evaluation(struct_processus *s_etat_proc
  {
      integer8                        i;
      integer8                        j;
+     integer8                        k;
+     integer8                        l;
+     integer8                        niveau_initial;
+     integer8                        nombre_termes;
+     integer8                        registre_hauteur_pile_operationnelle;
+     integer8                        registre_position_courante;
      logical1                        drapeau_then;
      logical1                        erreur_evaluation;
+     logical1                        presence_compteur;
      logical1                        presence_egalite;
      logical1                        presence_fonction;
      logical1                        presence_variable;
- Line 76  evaluation(struct_processus *s_etat_proc
+ Line 84  evaluation(struct_processus *s_etat_proc
      struct_objet                    *s_sous_objet;
      struct_objet                    *s_copie_variable_partagee;
-     struct_variable                 *registre_variables;
      unsigned char                   autorisation_empilement_programme;
      unsigned char                   *instruction_courante;
      unsigned char                   *message;
- Line 85  evaluation(struct_processus *s_etat_proc
+ Line 91  evaluation(struct_processus *s_etat_proc
      unsigned char                   registre_evaluation_forcee;
      unsigned char                   registre_instruction_valide;
      unsigned char                   registre_mode_execution_programme;
-     unsigned char                   registre_retour_definition;
      unsigned char                   registre_test;
      unsigned char                   registre_test_2;
      unsigned char                   registre_type_evaluation;
-     unsigned int                    registre_erreur_execution;
+     int                             registre_erreur_execution;
-     unsigned int                    registre_erreur_systeme;
+     int                             registre_erreur_systeme;
-     unsigned int                    registre_exception;
+     int                             registre_exception;
-     unsigned long                   k;
-     unsigned long                   l;
-     unsigned long                   n;
-     unsigned long                   m;
-     unsigned long                   niveau_initial;
-     unsigned long                   nombre_termes;
-     unsigned long                   registre_hauteur_pile_operationnelle;
-     unsigned long                   registre_niveau_courant;
-     unsigned long                   registre_position_courante;
      void                            (*fonction)();
- Line 178  evaluation(struct_processus *s_etat_proc
+ Line 173  evaluation(struct_processus *s_etat_proc
              {
                  if ((*s_etat_processus).traitement_symbolique == 'N')
                  {
-                     if ((*s_etat_processus).s_liste_variables
+                     if ((*(*s_etat_processus).pointeur_variable_courante)
-                             [(*s_etat_processus).position_variable_courante]
                              .objet == NULL)
                      {
                          // 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;
                          if (recherche_variable_partagee(s_etat_processus,
-                                 ((*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                 [(*s_etat_processus)
+                                 .pointeur_variable_courante).nom,
-                                 .position_variable_courante]).nom,
+                                 (*(*s_etat_processus)
-                                 ((*s_etat_processus).s_liste_variables
+                                 .pointeur_variable_courante)
-                                 [(*s_etat_processus)
+                                 .variable_partagee, 'E') != NULL)
-                                 .position_variable_courante])
-                                 .variable_partagee, 'E') == d_vrai)
                          {
                              presence_variable = 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;
                              }
- Line 219  evaluation(struct_processus *s_etat_proc
+ Line 200  evaluation(struct_processus *s_etat_proc
                              if ((s_copie_variable_partagee =
                                      copie_objet(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 =
                                          d_es_allocation_memoire;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 240  evaluation(struct_processus *s_etat_proc
+ Line 219  evaluation(struct_processus *s_etat_proc
                              }
                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                     .s_liste_variables_partagees).mutex))
+                                     .pointeur_variable_partagee_courante)
-                                     != 0)
+                                     .mutex)) != 0)
                              {
                                  (*s_etat_processus).erreur_systeme =
                                          d_es_processus;
- Line 253  evaluation(struct_processus *s_etat_proc
+ Line 232  evaluation(struct_processus *s_etat_proc
                              (*s_etat_processus).erreur_systeme = d_es;
                              presence_variable = 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
- Line 269  evaluation(struct_processus *s_etat_proc
+ Line 240  evaluation(struct_processus *s_etat_proc
                          presence_variable = d_vrai;
-                         if ((*((*s_etat_processus).s_liste_variables
+                         if ((*(*(*s_etat_processus).pointeur_variable_courante)
-                                 [(*s_etat_processus).position_variable_courante]
+                                 .objet).type == ADR)
-                                 .objet)).type == ADR)
                          {
                              presence_fonction = d_vrai;
                          }
- Line 315  evaluation(struct_processus *s_etat_proc
+ Line 285  evaluation(struct_processus *s_etat_proc
                  (*s_etat_processus).autorisation_empilement_programme = 'N';
                  (*(*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)
                  {
                      (*s_etat_processus).position_courante =
-                             (*((unsigned long *)
+                             (*((integer8 *) ((*(*(*s_etat_processus)
-                             ((*((*s_etat_processus).s_liste_variables
+                             .pointeur_variable_courante).objet).objet)));
-                             [(*s_etat_processus)
-                             .position_variable_courante]
-                             .objet)).objet)));
                  }
                  else
                  {
                      (*s_etat_processus).position_courante =
-                             (*((unsigned long *) (*s_copie_variable_partagee)
+                             (*((integer8 *) (*s_copie_variable_partagee)
                              .objet));
                      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)
                  {
                      profilage(s_etat_processus,
-                             (*s_etat_processus).s_liste_variables
+                             (*(*s_etat_processus).pointeur_variable_courante)
-                             [(*s_etat_processus).position_variable_courante]
                              .nom);
                      if ((*s_etat_processus).erreur_systeme != d_es)
- Line 366  evaluation(struct_processus *s_etat_proc
+ Line 323  evaluation(struct_processus *s_etat_proc
                  if (sequenceur(s_etat_processus) == d_erreur)
                  {
+                     depilement_pile_systeme(s_etat_processus);
                      (*s_etat_processus).evaluation_forcee =
                              registre_evaluation_forcee;
                      (*s_etat_processus).mode_execution_programme =
- Line 399  evaluation(struct_processus *s_etat_proc
+ Line 358  evaluation(struct_processus *s_etat_proc
                  registre_evaluation_expression_compilee =
                          (*s_etat_processus).evaluation_expression_compilee;
-                 if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)
+                 if (((*(*s_etat_processus).pointeur_variable_courante).origine
-                         .position_variable_courante].origine == 'E') &&
+                         == 'E') && ((*(*s_etat_processus)
-                         ((*s_etat_processus).s_liste_variables
+                         .pointeur_variable_courante).niveau == 0))
-                         [(*s_etat_processus).position_variable_courante].niveau
-                         == 0))
                  {
                      (*s_etat_processus).evaluation_expression_compilee = 'Y';
                  }
- Line 415  evaluation(struct_processus *s_etat_proc
+ Line 372  evaluation(struct_processus *s_etat_proc
                  if ((*s_etat_processus).profilage == d_vrai)
                  {
                      profilage(s_etat_processus,
-                             (*s_etat_processus).s_liste_variables
+                             (*(*s_etat_processus).pointeur_variable_courante)
-                             [(*s_etat_processus).position_variable_courante]
                              .nom);
                      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);
                      }
                  }
- Line 465  evaluation(struct_processus *s_etat_proc
+ Line 410  evaluation(struct_processus *s_etat_proc
                          .niveau_courant = (*s_etat_processus)
                          .niveau_courant;
-                 empilement_pile_systeme(s_etat_processus);
                  if (presence_variable_partagee == d_faux)
                  {
-                     if (evaluation(s_etat_processus, (*s_etat_processus)
+                     if (evaluation(s_etat_processus, (*(*s_etat_processus)
-                             .s_liste_variables[(*s_etat_processus)
+                             .pointeur_variable_courante).objet,
-                             .position_variable_courante].objet,
                              type_evaluation) == d_erreur)
                      {
                          if ((*s_etat_processus).profilage == d_vrai)
- Line 479  evaluation(struct_processus *s_etat_proc
+ Line 421  evaluation(struct_processus *s_etat_proc
                              profilage(s_etat_processus, NULL);
                          }
+                         depilement_pile_systeme(s_etat_processus);
                          (*s_etat_processus).evaluation_expression_compilee =
                                  registre_evaluation_expression_compilee;
- Line 501  evaluation(struct_processus *s_etat_proc
+ Line 445  evaluation(struct_processus *s_etat_proc
                              profilage(s_etat_processus, NULL);
                          }
+                         depilement_pile_systeme(s_etat_processus);
                          (*s_etat_processus).evaluation_expression_compilee =
                                  registre_evaluation_expression_compilee;
- Line 520  evaluation(struct_processus *s_etat_proc
+ Line 466  evaluation(struct_processus *s_etat_proc
                  }
                  depilement_pile_systeme(s_etat_processus);
-                 depilement_pile_systeme(s_etat_processus);
                  if ((*s_etat_processus).erreur_systeme != d_es)
                  {
- Line 768  evaluation(struct_processus *s_etat_proc
+ Line 713  evaluation(struct_processus *s_etat_proc
           * Exécution de la séquence d'instructions
           */
-         registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
-                 .retour_definition;
-         (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
-         (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
-                 s_objet;
          l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
          autorisation_empilement_programme = (*s_etat_processus)
                  .autorisation_empilement_programme;
- Line 815  evaluation(struct_processus *s_etat_proc
+ Line 754  evaluation(struct_processus *s_etat_proc
                              ((*s_etat_processus).erreur_systeme == d_es) &&
                              ((*s_etat_processus).exception == d_ep))
                      {
+                         registre_evaluation_expression_compilee =
+                                 (*s_etat_processus)
+                                 .evaluation_expression_compilee;
+                         (*s_etat_processus).evaluation_expression_compilee
+                                 = 'Y';
                          analyse(s_etat_processus, (*((struct_fonction *)
                                  (*(*l_element_courant).donnee).objet))
                                  .fonction);
+                         (*s_etat_processus).evaluation_expression_compilee =
+                                 registre_evaluation_expression_compilee;
                          if (type_evaluation == 'I')
                          {
                              (*s_etat_processus).derniere_erreur_evaluation =
- Line 836  evaluation(struct_processus *s_etat_proc
+ Line 785  evaluation(struct_processus *s_etat_proc
                          if ((*s_etat_processus).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
                          {
- Line 926  evaluation(struct_processus *s_etat_proc
+ Line 875  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 946  evaluation(struct_processus *s_etat_proc
+ Line 897  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 958  evaluation(struct_processus *s_etat_proc
+ Line 917  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
+                                             }
                                              else
                                              {
                                                  empilement_pile_systeme(
- Line 1001  evaluation(struct_processus *s_etat_proc
+ Line 988  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 1013  evaluation(struct_processus *s_etat_proc
+ Line 1008  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
+                                             }
                                              else
                                              {
+                                                 // Traitement spécifique pour
+                                                 // la fin d'une section
+                                                 // critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme
+                                                         == NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         liberation(
+                                                         s_etat_processus,
+                                                         s_objet_evalue);
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 1098  evaluation(struct_processus *s_etat_proc
+ Line 1267  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 1111  evaluation(struct_processus *s_etat_proc
+ Line 1282  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
                                              }
                                              else
                                              {
- Line 1153  evaluation(struct_processus *s_etat_proc
+ Line 1360  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
                                              }
                                              else
                                              {
+                                                 // Traitement spécifique pour
+                                                 // la fin d'une section
+                                                 // critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme
+                                                         == NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
                                              }
- Line 1251  evaluation(struct_processus *s_etat_proc
+ Line 1644  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 1264  evaluation(struct_processus *s_etat_proc
+ Line 1659  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
                                              }
                                              else
                                              {
- Line 1306  evaluation(struct_processus *s_etat_proc
+ Line 1737  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 1320  evaluation(struct_processus *s_etat_proc
+ Line 1759  evaluation(struct_processus *s_etat_proc
                                                      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
                                              {
+                                                 // Traitement spécifique pour
+                                                 // la fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme
+                                                         == NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 1363  evaluation(struct_processus *s_etat_proc
+ Line 1979  evaluation(struct_processus *s_etat_proc
                              if ((*s_etat_processus)
                                      .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
                              {
- Line 1674  evaluation(struct_processus *s_etat_proc
+ Line 2290  evaluation(struct_processus *s_etat_proc
                          return(d_erreur);
                      }
-                     if ((*s_etat_processus).s_liste_variables
+                     if ((*(*s_etat_processus).pointeur_variable_courante).objet
-                             [(*s_etat_processus).position_variable_courante]
+                             == NULL)
-                             .objet == 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,
-                                 ((*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                 [(*s_etat_processus)
+                                 .pointeur_variable_courante).nom,
-                                 .position_variable_courante]).nom,
+                                 (*(*s_etat_processus)
-                                 ((*s_etat_processus).s_liste_variables
+                                 .pointeur_variable_courante).variable_partagee,
-                                 [(*s_etat_processus)
+                                 'E') != NULL)
-                                 .position_variable_courante])
-                                 .variable_partagee, 'E') == d_vrai)
                          {
                              // Une variable partagée existe.
                              presence_variable_partagee = d_vrai;
-                             (*s_etat_processus).s_liste_variables
+                             (*(*s_etat_processus).pointeur_variable_courante)
-                                     [(*s_etat_processus)
+                                     .objet = (*(*s_etat_processus)
-                                     .position_variable_courante].objet =
+                                     .pointeur_variable_partagee_courante)
-                                     (*(*s_etat_processus)
+                                     .objet;
-                                     .s_liste_variables_partagees).table
-                                     [(*(*s_etat_processus)
-                                     .s_liste_variables_partagees)
-                                     .position_variable].objet;
                          }
                          else
                          {
                              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
- Line 1728  evaluation(struct_processus *s_etat_proc
+ Line 2323  evaluation(struct_processus *s_etat_proc
                       * Recherche d'un élément dans un vecteur
                       */
-                     if (((*s_etat_processus).s_liste_variables
+                     if ((*(*s_etat_processus).pointeur_variable_courante)
-                             [(*s_etat_processus).position_variable_courante])
                              .objet == NULL)
                      {
                          // La variable partagée n'existe plus.
- Line 1742  evaluation(struct_processus *s_etat_proc
+ Line 2336  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet =
                                          NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 1761  evaluation(struct_processus *s_etat_proc
+ Line 2354  evaluation(struct_processus *s_etat_proc
                              return(d_erreur);;
                          }
                      }
-                     else if ((((*(((*s_etat_processus).s_liste_variables
+                     else if ((((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == VIN) ||
-                             .objet)).type == VIN) ||
+                             ((*((*(*s_etat_processus)
-                             ((*(((*s_etat_processus).s_liste_variables
+                             .pointeur_variable_courante).objet)).type == VRL) ||
-                             [(*s_etat_processus).position_variable_courante])
+                             ((*((*(*s_etat_processus)
-                             .objet)).type == VRL) ||
+                             .pointeur_variable_courante).objet)).type == VCX))
-                             ((*(((*s_etat_processus).s_liste_variables
-                             [(*s_etat_processus).position_variable_courante])
-                             .objet)).type == VCX))
                              && ((*((struct_fonction *) (*(*l_element_courant)
                              .donnee).objet)).nombre_arguments == 1))
                      {
- Line 1780  evaluation(struct_processus *s_etat_proc
+ Line 2370  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet =
                                          NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 1808  evaluation(struct_processus *s_etat_proc
+ Line 2397  evaluation(struct_processus *s_etat_proc
                              return(d_erreur);
                          }
-                         if ((*s_objet_indice_i).type == INT)
+                         if ((*s_objet_indice_i).type != INT)
                          {
                              liberation(s_etat_processus, s_objet_indice_i);
                              free(s_objet_elementaire);
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet =
                                          NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 1848  evaluation(struct_processus *s_etat_proc
+ Line 2436  evaluation(struct_processus *s_etat_proc
                          liberation(s_etat_processus, s_objet_indice_i);
                          if ((i < 1) || (i > (integer8) (*((struct_vecteur *)
-                                 (*(((*s_etat_processus)
+                                 (*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).objet))
-                                 .position_variable_courante]).objet)).objet))
                                  .taille))
                          {
                              free(s_objet_elementaire);
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet =
                                          NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 1885  evaluation(struct_processus *s_etat_proc
+ Line 2471  evaluation(struct_processus *s_etat_proc
                              return(d_erreur);
                          }
-                         if ((*(((*s_etat_processus).s_liste_variables
+                         if ((*((*(*s_etat_processus)
-                                 [(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).type
-                                 .position_variable_courante]).objet)).type
                                  == VIN)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
- Line 1901  evaluation(struct_processus *s_etat_proc
+ Line 2486  evaluation(struct_processus *s_etat_proc
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 1926  evaluation(struct_processus *s_etat_proc
+ Line 2510  evaluation(struct_processus *s_etat_proc
                              (*s_objet_elementaire).type = INT;
                              (*((integer8 *) (*s_objet_elementaire).objet)) =
                                      ((integer8 *) (*((struct_vecteur *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1];
                          }
-                         else if ((*(((*s_etat_processus)
+                         else if ((*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).type
-                                 .position_variable_courante]).objet)).type
                                  == VRL)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
- Line 1941  evaluation(struct_processus *s_etat_proc
+ Line 2523  evaluation(struct_processus *s_etat_proc
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 1972  evaluation(struct_processus *s_etat_proc
+ Line 2553  evaluation(struct_processus *s_etat_proc
                              (*s_objet_elementaire).type = REL;
                              (*((real8 *) (*s_objet_elementaire).objet)) =
                                      ((real8 *) (*((struct_vecteur *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1];
                          }
-                         else if ((*(((*s_etat_processus)
+                         else if ((*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).type
-                                 .position_variable_courante]).objet)).type
                                  == VCX)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
- Line 1987  evaluation(struct_processus *s_etat_proc
+ Line 2566  evaluation(struct_processus *s_etat_proc
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 2019  evaluation(struct_processus *s_etat_proc
+ Line 2597  evaluation(struct_processus *s_etat_proc
                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                      .objet)).partie_reelle =
                                      ((struct_complexe16 *) (*((struct_vecteur *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
+                                     .objet)).tableau)[i - 1].partie_reelle;
-                                     .objet)).tableau)[i - 1]
-                                     .partie_reelle;
                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                      .objet)).partie_imaginaire =
                                      ((struct_complexe16 *) (*((struct_vecteur *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
+                                     .objet)).tableau)[i - 1].partie_imaginaire;
-                                     .objet)).tableau)[i - 1]
-                                     .partie_imaginaire;
                          }
                      }
- Line 2039  evaluation(struct_processus *s_etat_proc
+ Line 2613  evaluation(struct_processus *s_etat_proc
                       * Recherche d'un élément dans une matrice
                       */
-                     else if ((((*(((*s_etat_processus).s_liste_variables
+                     else if ((((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == MIN) ||
-                             .objet)).type == MIN) ||
+                             ((*((*(*s_etat_processus)
-                             ((*(((*s_etat_processus).s_liste_variables
+                             .pointeur_variable_courante).objet)).type == MRL) ||
-                             [(*s_etat_processus).position_variable_courante])
+                             ((*((*(*s_etat_processus)
-                             .objet)).type == MRL) ||
+                             .pointeur_variable_courante).objet)).type == MCX))
-                             ((*(((*s_etat_processus).s_liste_variables
-                             [(*s_etat_processus).position_variable_courante])
-                             .objet)).type == MCX))
                              && ((*((struct_fonction *) (*(*l_element_courant)
                              .donnee).objet)).nombre_arguments == 2))
                      {
- Line 2058  evaluation(struct_processus *s_etat_proc
+ Line 2629  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2095  evaluation(struct_processus *s_etat_proc
+ Line 2665  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2133  evaluation(struct_processus *s_etat_proc
+ Line 2702  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2169  evaluation(struct_processus *s_etat_proc
+ Line 2737  evaluation(struct_processus *s_etat_proc
                          liberation(s_etat_processus, s_objet_indice_j);
                          if ((i < 1) || (i > (integer8) (*((struct_matrice *)
-                                 (*(((*s_etat_processus)
+                                 (*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).objet))
-                                 .position_variable_courante]).objet)).objet))
                                  .nombre_lignes) || (j < 1) || (j > (integer8)
-                                 (*((struct_matrice *) (*(((*s_etat_processus)
+                                 (*((struct_matrice *) (*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).objet))
-                                 .position_variable_courante]).objet)).objet))
                                  .nombre_colonnes))
                          {
-                             liberation(s_etat_processus, s_objet_indice_i);
-                             liberation(s_etat_processus, s_objet_indice_j);
                              free(s_objet_elementaire);
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2213  evaluation(struct_processus *s_etat_proc
+ Line 2776  evaluation(struct_processus *s_etat_proc
                              return(d_erreur);
                          }
-                         if ((*(((*s_etat_processus).s_liste_variables
+                         if ((*((*(*s_etat_processus).pointeur_variable_courante)
-                                 [(*s_etat_processus)
+                                 .objet)).type == MIN)
-                                 .position_variable_courante]).objet)).type
-                                 == MIN)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
                                      integer8))) == NULL)
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 2254  evaluation(struct_processus *s_etat_proc
+ Line 2814  evaluation(struct_processus *s_etat_proc
                              (*s_objet_elementaire).type = INT;
                              (*((integer8 *) (*s_objet_elementaire).objet)) =
                                      ((integer8 **) (*((struct_matrice *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1][j - 1];
                          }
-                         else if ((*(((*s_etat_processus)
+                         else if ((*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).type
-                                 .position_variable_courante]).objet)).type
                                  == MRL)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
- Line 2269  evaluation(struct_processus *s_etat_proc
+ Line 2827  evaluation(struct_processus *s_etat_proc
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 2300  evaluation(struct_processus *s_etat_proc
+ Line 2857  evaluation(struct_processus *s_etat_proc
                              (*s_objet_elementaire).type = REL;
                              (*((real8 *) (*s_objet_elementaire).objet)) =
                                      ((real8 **) (*((struct_matrice *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1][j - 1];
                          }
-                         else if ((*(((*s_etat_processus)
+                         else if ((*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).type
-                                 .position_variable_courante]).objet)).type
                                  == MCX)
                          {
                              if (((*s_objet_elementaire).objet = malloc(sizeof(
- Line 2315  evaluation(struct_processus *s_etat_proc
+ Line 2870  evaluation(struct_processus *s_etat_proc
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 2348  evaluation(struct_processus *s_etat_proc
+ Line 2902  evaluation(struct_processus *s_etat_proc
                                      .objet)).partie_reelle =
                                      ((struct_complexe16 **)
                                      (*((struct_matrice *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1][j - 1]
                                      .partie_reelle;
                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                      .objet)).partie_imaginaire =
                                      ((struct_complexe16 **)
                                      (*((struct_matrice *)
-                                     (*(((*s_etat_processus).s_liste_variables
+                                     (*((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet))
-                                     .position_variable_courante]).objet))
                                      .objet)).tableau)[i - 1][j - 1]
                                      .partie_imaginaire;
                          }
- Line 2369  evaluation(struct_processus *s_etat_proc
+ Line 2921  evaluation(struct_processus *s_etat_proc
                       * Recherche de l'élément idoine dans la liste
                       */
-                     else if (((*(((*s_etat_processus).s_liste_variables
+                     else if (((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == LST) &&
-                             .objet)).type == LST) &&
                              ((*((struct_fonction *) (*(*l_element_courant)
                              .donnee).objet)).nombre_arguments == 1))
                      {
- Line 2382  evaluation(struct_processus *s_etat_proc
+ Line 2933  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2418  evaluation(struct_processus *s_etat_proc
+ Line 2968  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2451  evaluation(struct_processus *s_etat_proc
+ Line 3000  evaluation(struct_processus *s_etat_proc
                          liberation(s_etat_processus, s_objet_indice_i);
-                         l_sous_element_courant = (*(((*s_etat_processus)
+                         l_sous_element_courant = (*((*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)).objet;
-                                 .position_variable_courante]).objet)).objet;
                          j = 0;
                          while(l_sous_element_courant != NULL)
- Line 2473  evaluation(struct_processus *s_etat_proc
+ Line 3021  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2510  evaluation(struct_processus *s_etat_proc
+ Line 3057  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2536  evaluation(struct_processus *s_etat_proc
+ Line 3082  evaluation(struct_processus *s_etat_proc
                                      instruction_courante;
                              return(d_erreur);
                          }
+                         // Si l'objet élémentaire est un nom et que ce nom n'est
+                         // pas un nom symbolique, il convient de l'évaluer.
+                         if ((*s_objet_elementaire).type == NOM)
+                         {
+                             if (((*((struct_nom *) (*s_objet_elementaire)
+                                     .objet)).symbole == d_faux) ||
+                                     (type_evaluation == 'N'))
+                             {
+                                 if (evaluation(s_etat_processus,
+                                         s_objet_elementaire, 'E') == d_erreur)
+                                 {
+                                     if (presence_variable_partagee == d_vrai)
+                                     {
+                                         (*(*s_etat_processus)
+                                                 .pointeur_variable_courante)
+                                                 .objet = NULL;
+                                         if (pthread_mutex_unlock(
+                                             &((*(*s_etat_processus)
+                                             .pointeur_variable_partagee_courante
+                                             ).mutex)) != 0)
+                                         {
+                                             (*s_etat_processus).erreur_systeme =
+                                                     d_es_processus;
+                                         }
+                                     }
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_allocation_memoire;
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 liberation(s_etat_processus,
+                                         s_objet_elementaire);
+                                 if (depilement(s_etat_processus,
+                                         &((*s_etat_processus).l_base_pile),
+                                         &s_objet_elementaire) == d_erreur)
+                                 {
+                                     if (presence_variable_partagee == d_vrai)
+                                     {
+                                         (*(*s_etat_processus)
+                                                 .pointeur_variable_courante)
+                                                 .objet = NULL;
+                                         if (pthread_mutex_unlock(
+                                             &((*(*s_etat_processus)
+                                             .pointeur_variable_partagee_courante
+                                             ).mutex)) != 0)
+                                         {
+                                             (*s_etat_processus).erreur_systeme =
+                                                     d_es_processus;
+                                         }
+                                     }
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_allocation_memoire;
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                             }
+                         }
                      }
                      /*
                       * Recherche de l'élément idoine dans la table
                       */
-                     else if (((*(((*s_etat_processus).s_liste_variables
+                     else if (((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == TBL) &&
-                             .objet)).type == TAB) &&
                              ((*((struct_fonction *) (*(*l_element_courant)
                              .donnee).objet)).nombre_arguments == 1))
                      {
- Line 2555  evaluation(struct_processus *s_etat_proc
+ Line 3180  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2591  evaluation(struct_processus *s_etat_proc
+ Line 3215  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2625  evaluation(struct_processus *s_etat_proc
+ Line 3248  evaluation(struct_processus *s_etat_proc
                          liberation(s_etat_processus, s_objet_indice_i);
                          if ((i < 1) || (i > (integer8) (*((struct_tableau *)
-                                 (*((*s_etat_processus).s_liste_variables
+                                 (*(*(*s_etat_processus)
-                                 [(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)
-                                 .position_variable_courante]).objet)
                                  .objet)).nombre_elements))
                          {
                              free(s_objet_elementaire);
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2667  evaluation(struct_processus *s_etat_proc
+ Line 3288  evaluation(struct_processus *s_etat_proc
                          if ((s_objet_elementaire =
                                  copie_objet(s_etat_processus,
-                                 (*((struct_tableau *) (*((*s_etat_processus)
+                                 (*((struct_tableau *) (*(*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet)
-                                 .position_variable_courante]).objet)
                                  .objet)).elements[i - 1], 'P')) == NULL)
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2700  evaluation(struct_processus *s_etat_proc
+ Line 3319  evaluation(struct_processus *s_etat_proc
                                      instruction_courante;
                              return(d_erreur);
                          }
+                         // Si l'objet élémentaire est un nom et que ce nom n'est
+                         // pas un nom symbolique, il convient de l'évaluer.
+                         if ((*s_objet_elementaire).type == NOM)
+                         {
+                             if (((*((struct_nom *) (*s_objet_elementaire)
+                                     .objet)).symbole == d_faux) ||
+                                     (type_evaluation == 'N'))
+                             {
+                                 if (evaluation(s_etat_processus,
+                                         s_objet_elementaire, 'E') == d_erreur)
+                                 {
+                                     if (presence_variable_partagee == d_vrai)
+                                     {
+                                         (*(*s_etat_processus)
+                                                 .pointeur_variable_courante)
+                                                 .objet = NULL;
+                                         if (pthread_mutex_unlock(
+                                             &((*(*s_etat_processus)
+                                             .pointeur_variable_partagee_courante
+                                             ).mutex)) != 0)
+                                         {
+                                             (*s_etat_processus).erreur_systeme =
+                                                     d_es_processus;
+                                         }
+                                     }
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_allocation_memoire;
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 liberation(s_etat_processus,
+                                         s_objet_elementaire);
+                                 if (depilement(s_etat_processus,
+                                         &((*s_etat_processus).l_base_pile),
+                                         &s_objet_elementaire) == d_erreur)
+                                 {
+                                     if (presence_variable_partagee == d_vrai)
+                                     {
+                                         (*(*s_etat_processus)
+                                                 .pointeur_variable_courante)
+                                                 .objet = NULL;
+                                         if (pthread_mutex_unlock(
+                                             &((*(*s_etat_processus)
+                                             .pointeur_variable_partagee_courante
+                                             ).mutex)) != 0)
+                                         {
+                                             (*s_etat_processus).erreur_systeme =
+                                                     d_es_processus;
+                                         }
+                                     }
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_allocation_memoire;
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                             }
+                         }
                      }
-                     else if (((*(((*s_etat_processus).s_liste_variables
+                     else if (((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == ALG) ||
-                             .objet)).type == ALG) ||
+                             ((*((*(*s_etat_processus)
-                             ((*(((*s_etat_processus).s_liste_variables
+                             .pointeur_variable_courante).objet)).type == RPN))
-                             [(*s_etat_processus).position_variable_courante])
-                             .objet)).type == RPN))
                      {
                          registre_evaluation_expression_compilee =
                                  (*s_etat_processus)
                                  .evaluation_expression_compilee;
-                         if (((*s_etat_processus).s_liste_variables
+                         if (((*(*s_etat_processus).pointeur_variable_courante)
-                                 [(*s_etat_processus)
+                                 .origine == 'E') && ((*(*s_etat_processus)
-                                 .position_variable_courante].origine == 'E') &&
+                                 .pointeur_variable_courante).niveau == 0))
-                                 ((*s_etat_processus).s_liste_variables
-                                 [(*s_etat_processus).position_variable_courante]
-                                 .niveau == 0))
                          {
                              (*s_etat_processus).evaluation_expression_compilee =
                                      'Y';
- Line 2728  evaluation(struct_processus *s_etat_proc
+ Line 3422  evaluation(struct_processus *s_etat_proc
                                      'N';
                          }
-                         if (evaluation(s_etat_processus, (*s_etat_processus)
+                         if (evaluation(s_etat_processus, (*(*s_etat_processus)
-                                 .s_liste_variables[(*s_etat_processus)
+                                 .pointeur_variable_courante).objet,
-                                 .position_variable_courante].objet,
                                  type_evaluation) == d_erreur)
                          {
                              (*s_etat_processus).evaluation_expression_compilee =
- Line 2738  evaluation(struct_processus *s_etat_proc
+ Line 3431  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2776  evaluation(struct_processus *s_etat_proc
+ Line 3468  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2805  evaluation(struct_processus *s_etat_proc
+ Line 3496  evaluation(struct_processus *s_etat_proc
                              return(d_erreur);
                          }
                      }
-                     else if ((*(((*s_etat_processus).s_liste_variables
+                     else if ((*((*(*s_etat_processus)
-                             [(*s_etat_processus).position_variable_courante])
+                             .pointeur_variable_courante).objet)).type == ADR)
-                             .objet)).type == ADR)
                      {
                          autorisation_empilement_programme = (*s_etat_processus)
                                  .autorisation_empilement_programme;
- Line 2820  evaluation(struct_processus *s_etat_proc
+ Line 3510  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(
                                          &((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2840  evaluation(struct_processus *s_etat_proc
+ Line 3529  evaluation(struct_processus *s_etat_proc
                                  liberation(s_etat_processus, s_objet_evalue);
                              }
+                             depilement_pile_systeme(s_etat_processus);
                              (*s_etat_processus).instruction_courante =
                                      instruction_courante;
                              return(d_erreur);
- Line 2859  evaluation(struct_processus *s_etat_proc
+ Line 3550  evaluation(struct_processus *s_etat_proc
                                  .niveau_courant;
                          (*s_etat_processus).position_courante =
-                                 (*((unsigned long *)
+                                 (*((integer8 *) ((*(*(*s_etat_processus)
-                                 ((*((*s_etat_processus).s_liste_variables
+                                 .pointeur_variable_courante).objet).objet)));
-                                 [(*s_etat_processus)
-                                 .position_variable_courante]
-                                 .objet)).objet)));
                          if ((*s_etat_processus).profilage == d_vrai)
                          {
                              profilage(s_etat_processus,
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).nom);
-                                     .position_variable_courante].nom);
                              if ((*s_etat_processus).erreur_systeme != d_es)
                              {
                                  if (presence_variable_partagee == d_vrai)
                                  {
-                                     (*s_etat_processus).s_liste_variables
+                                     (*(*s_etat_processus)
-                                             [(*s_etat_processus)
+                                             .pointeur_variable_courante).objet =
-                                             .position_variable_courante].objet
+                                             NULL;
-                                             = NULL;
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 2910  evaluation(struct_processus *s_etat_proc
+ Line 3596  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2929  evaluation(struct_processus *s_etat_proc
+ Line 3614  evaluation(struct_processus *s_etat_proc
                                  liberation(s_etat_processus, s_objet_evalue);
                              }
+                             depilement_pile_systeme(s_etat_processus);
                              (*s_etat_processus).instruction_courante =
                                      instruction_courante;
                              (*s_etat_processus).mode_execution_programme =
- Line 2948  evaluation(struct_processus *s_etat_proc
+ Line 3635  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees)
+                                         .pointeur_variable_partagee_courante)
                                          .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
- Line 2984  evaluation(struct_processus *s_etat_proc
+ Line 3670  evaluation(struct_processus *s_etat_proc
                          {
                              if (presence_variable_partagee == d_vrai)
                              {
-                                 (*s_etat_processus).s_liste_variables
+                                 (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet =
-                                         .position_variable_courante].objet
+                                         NULL;
-                                         = NULL;
                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                         .s_liste_variables_partagees).mutex))
+                                         .pointeur_variable_partagee_courante)
-                                         != 0)
+                                         .mutex)) != 0)
                                  {
                                      (*s_etat_processus).erreur_systeme =
                                              d_es_processus;
- Line 3016  evaluation(struct_processus *s_etat_proc
+ Line 3701  evaluation(struct_processus *s_etat_proc
                      {
                          if (presence_variable_partagee == d_vrai)
                          {
-                             (*s_etat_processus).s_liste_variables
+                             (*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet =
-                                     .position_variable_courante].objet
+                                     NULL;
-                                     = NULL;
                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                     .s_liste_variables_partagees) .mutex)) != 0)
+                                     .pointeur_variable_partagee_courante)
+                                     .mutex)) != 0)
                              {
                                  (*s_etat_processus).erreur_systeme =
                                          d_es_processus;
- Line 3049  evaluation(struct_processus *s_etat_proc
+ Line 3734  evaluation(struct_processus *s_etat_proc
                      {
                          if (presence_variable_partagee == d_vrai)
                          {
-                             (*s_etat_processus).s_liste_variables
+                             (*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet =
-                                     .position_variable_courante].objet
+                                     NULL;
-                                     = NULL;
                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                     .s_liste_variables_partagees).mutex)) != 0)
+                                     .pointeur_variable_partagee_courante)
+                                     .mutex)) != 0)
                              {
                                  (*s_etat_processus).erreur_systeme =
                                          d_es_processus;
- Line 3074  evaluation(struct_processus *s_etat_proc
+ Line 3759  evaluation(struct_processus *s_etat_proc
                      if (presence_variable_partagee == d_vrai)
                      {
-                         (*s_etat_processus).s_liste_variables
+                         (*(*s_etat_processus)
-                                 [(*s_etat_processus)
+                                 .pointeur_variable_courante).objet = NULL;
-                                 .position_variable_courante].objet
-                                 = NULL;
                          if (pthread_mutex_unlock(&((*(*s_etat_processus)
-                                 .s_liste_variables_partagees).mutex)) != 0)
+                                 .pointeur_variable_partagee_courante).mutex))
+                                 != 0)
                          {
                              (*s_etat_processus).erreur_systeme =
                                      d_es_processus;
- Line 3132  evaluation(struct_processus *s_etat_proc
+ Line 3816  evaluation(struct_processus *s_etat_proc
                                  .evaluation_expression_compilee;
                          (*s_etat_processus).evaluation_expression_compilee
-                                 = 'N';
+                                 = 'Y';
                          if (evaluation(s_etat_processus, (*l_element_courant)
                                  .donnee, type_evaluation) == d_erreur)
- Line 3242  evaluation(struct_processus *s_etat_proc
+ Line 3926  evaluation(struct_processus *s_etat_proc
                          if ((*s_etat_processus).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
                          {
- Line 3331  evaluation(struct_processus *s_etat_proc
+ Line 4015  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 3351  evaluation(struct_processus *s_etat_proc
+ Line 4037  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 3363  evaluation(struct_processus *s_etat_proc
+ Line 4057  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
+                                             }
                                              else
                                              {
                                                  empilement_pile_systeme(
- Line 3406  evaluation(struct_processus *s_etat_proc
+ Line 4128  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 3418  evaluation(struct_processus *s_etat_proc
+ Line 4148  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
+                                             }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 3451  evaluation(struct_processus *s_etat_proc
+ Line 4358  evaluation(struct_processus *s_etat_proc
                              do
                              {
+                                 l_element_courant = (*l_element_courant)
+                                         .suivant;
                                  l_registre_atome = l_element_courant;
                                  if (l_element_courant == NULL)
- Line 3490  evaluation(struct_processus *s_etat_proc
+ Line 4399  evaluation(struct_processus *s_etat_proc
                                      drapeau_then = TEST(instruction_then)
                                              ? d_vrai : d_faux;
                                  }
-                                 l_element_courant = (*l_element_courant)
-                                         .suivant;
                              } while(drapeau_then == d_faux);
                              (*s_etat_processus).expression_courante =
- Line 3541  evaluation(struct_processus *s_etat_proc
+ Line 4447  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 3554  evaluation(struct_processus *s_etat_proc
+ Line 4462  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
                                              }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
+                                             }
                                              else
                                              {
                                                  empilement_pile_systeme(
- Line 3596  evaluation(struct_processus *s_etat_proc
+ Line 4540  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
                                              }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 3691  evaluation(struct_processus *s_etat_proc
+ Line 4820  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 3704  evaluation(struct_processus *s_etat_proc
+ Line 4835  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
                                              }
                                              else
                                              {
- Line 3746  evaluation(struct_processus *s_etat_proc
+ Line 4913  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
                                              }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
+                                             }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 3795  evaluation(struct_processus *s_etat_proc
+ Line 5147  evaluation(struct_processus *s_etat_proc
                              if ((*s_etat_processus)
                                      .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
                              {
- Line 3823  evaluation(struct_processus *s_etat_proc
+ Line 5175  evaluation(struct_processus *s_etat_proc
                          if ((*s_etat_processus).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
                          {
- Line 3912  evaluation(struct_processus *s_etat_proc
+ Line 5264  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 3932  evaluation(struct_processus *s_etat_proc
+ Line 5286  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 3944  evaluation(struct_processus *s_etat_proc
+ Line 5306  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
+                                             }
                                              else
                                              {
                                                  empilement_pile_systeme(
- Line 3987  evaluation(struct_processus *s_etat_proc
+ Line 5377  evaluation(struct_processus *s_etat_proc
                                                  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;
- Line 3999  evaluation(struct_processus *s_etat_proc
+ Line 5397  evaluation(struct_processus *s_etat_proc
                                                      .erreur_execution =
                                                      registre_erreur_execution;
                                              }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
+                                             }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 4032  evaluation(struct_processus *s_etat_proc
+ Line 5607  evaluation(struct_processus *s_etat_proc
                              do
                              {
+                                 (*s_etat_processus).expression_courante =
+                                         l_registre_atome;
                                  l_registre_atome = l_element_courant;
                                  if (l_element_courant == NULL)
- Line 4076  evaluation(struct_processus *s_etat_proc
+ Line 5653  evaluation(struct_processus *s_etat_proc
                                          .suivant;
                              } while(drapeau_then == d_faux);
-                             (*s_etat_processus).expression_courante =
-                                     l_registre_atome;
                              (*(*s_etat_processus).l_base_pile_systeme)
                                      .clause = 'X';
                              instruction_then(s_etat_processus);
- Line 4122  evaluation(struct_processus *s_etat_proc
+ Line 5696  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 4135  evaluation(struct_processus *s_etat_proc
+ Line 5711  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
                                              }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
+                                             }
                                              else
                                              {
                                                  empilement_pile_systeme(
- Line 4177  evaluation(struct_processus *s_etat_proc
+ Line 5789  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
                                              }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 4272  evaluation(struct_processus *s_etat_proc
+ Line 6069  evaluation(struct_processus *s_etat_proc
                                                  TEST(instruction_do) ||
                                                  TEST(instruction_while) ||
                                                  TEST(instruction_for) ||
+                                                 TEST(instruction_forall) ||
                                                  TEST(instruction_start) ||
                                                  TEST(instruction_select) ||
                                                  TEST(instruction_case) ||
+                                                 TEST(instruction_critical) ||
                                                  TEST(vers_niveau_superieur))
                                          {
                                              if (TEST(vers_niveau_superieur))
- Line 4285  evaluation(struct_processus *s_etat_proc
+ Line 6084  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                             }
+                                             else if (TEST(instruction_for) ||
+                                                     TEST(instruction_forall) ||
+                                                     TEST(instruction_start))
+                                             {
+                                                 empilement_pile_systeme(
+                                                         s_etat_processus);
+                                                 if ((*s_etat_processus)
+                                                         .erreur_systeme != d_es)
+                                                 {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
+                                                 (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture = 'L';
                                              }
                                              else
                                              {
- Line 4327  evaluation(struct_processus *s_etat_proc
+ Line 6162  evaluation(struct_processus *s_etat_proc
                                                  if ((*s_etat_processus)
                                                          .erreur_systeme != d_es)
                                                  {
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
                                                      (*s_etat_processus)
                                                          .instruction_courante =
                                                          instruction_courante;
                                                      return(d_erreur);
                                                  }
                                              }
+                                             else if ((TEST(instruction_next) ||
+                                                     TEST(instruction_step)) &&
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'L'))
+                                             {
+                                                 /*
+                                                  * Libération des compteurs
+                                                  * de boucle
+                                                  */
+                                                 presence_compteur =
+                                                     (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'F') ||
+                                                     ((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture == 'A'))
+                                                     ? d_vrai : d_faux;
+                                                 if (((*(*s_etat_processus)
+                                                     .l_base_pile_systeme)
+                                                     .type_cloture != 'S') &&
+                                                     (presence_compteur ==
+                                                     d_faux))
+                                                 {
+                                                     (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if (presence_compteur == d_vrai)
+                                                 {
+                                                     if (recherche_variable(
+                                                         s_etat_processus,
+                                                         (*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .nom_variable) ==
+                                                         d_faux)
+                                                     {
+                                                         (*s_etat_processus)
+                                                 .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                 .erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     if ((*(*s_etat_processus)
+                                                     .pointeur_variable_courante)
+                                                     .objet == NULL)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme = d_es;
+                                                         (*s_etat_processus)
+                                                         .erreur_execution =
+                                                         d_ex_variable_partagee;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .niveau_courant--;
+                                                     if (
+                                                 retrait_variables_par_niveau(
+                                                 s_etat_processus) == d_erreur)
+                                                     {
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                 }
+                                                 depilement_pile_systeme(
+                                                         s_etat_processus);
+                                             }
                                              else
                                              {
+                                                 // Traitement spécifique pour la
+                                                 // fin d'une section critique
+                                                 if ((*s_etat_processus)
+                                                         .l_base_pile_systeme ==
+                                                         NULL)
+                                                 {
+                                                     (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_end_incoherent;
+                                                     if (presence_egalite ==
+                                                             d_vrai)
+                                                     {
+                                                         liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                     return(d_erreur);
+                                                 }
+                                                 if ((*(*s_etat_processus)
+                                                         .l_base_pile_systeme)
+                                                         .type_cloture == 'Q')
+                                                 {
+                                                     if (pthread_mutex_unlock(
+                                                     &mutex_sections_critiques)
+                                                     != 0)
+                                                     {
+                                                         (*s_etat_processus)
+                                                         .erreur_systeme =
+                                                         d_es_processus;
+                                                         if (presence_egalite ==
+                                                                 d_vrai)
+                                                         {
+                                                             liberation(
+                                                             s_etat_processus,
+                                                             s_objet_evalue);
+                                                         }
+                                                         (*s_etat_processus)
+                                                         .instruction_courante =
+                                                         instruction_courante;
+                                                         return(d_erreur);
+                                                     }
+                                                     (*s_etat_processus)
+                                                         .sections_critiques--;
+                                                 }
                                                  depilement_pile_systeme(
                                                          s_etat_processus);
- Line 4367  evaluation(struct_processus *s_etat_proc
+ Line 6387  evaluation(struct_processus *s_etat_proc
                                      registre_mode_execution_programme;
                              (*s_etat_processus).instruction_courante =
                                      instruction_courante;
                              if (presence_egalite == d_vrai)
                              {
                                  liberation(s_etat_processus, s_objet_evalue);
- Line 4376  evaluation(struct_processus *s_etat_proc
+ Line 6395  evaluation(struct_processus *s_etat_proc
                              if ((*s_etat_processus)
                                      .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
                              {
- Line 4453  evaluation(struct_processus *s_etat_proc
+ Line 6472  evaluation(struct_processus *s_etat_proc
                      {
                          if ((*s_etat_processus).traitement_symbolique == 'N')
                          {
-                             if ((*s_etat_processus).s_liste_variables
+                             if ((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante).objet == NULL)
-                                     .position_variable_courante].objet == NULL)
                              {
                                  // 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;
                                  if (recherche_variable_partagee(
-                                         s_etat_processus,
+                                         s_etat_processus, (*(*s_etat_processus)
-                                         ((*s_etat_processus).s_liste_variables
+                                         .pointeur_variable_courante).nom,
-                                         [(*s_etat_processus)
+                                         (*(*s_etat_processus)
-                                         .position_variable_courante]).nom,
+                                         .pointeur_variable_courante)
-                                         ((*s_etat_processus).s_liste_variables
+                                         .variable_partagee, 'E') != NULL)
-                                         [(*s_etat_processus)
-                                         .position_variable_courante])
-                                         .variable_partagee, 'E') == d_vrai)
                                  {
                                      presence_variable = 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;
                                      }
- Line 4499  evaluation(struct_processus *s_etat_proc
+ Line 6502  evaluation(struct_processus *s_etat_proc
                                              .objet)).symbole == d_faux))
                                      {
                                          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(
-                                                     &((*(*s_etat_processus)
+                                             &((*(*s_etat_processus)
-                                                     .s_liste_variables_partagees
+                                             .pointeur_variable_partagee_courante
-                                                     ).mutex)) != 0)
+                                             ).mutex)) != 0)
                                              {
                                                  (*s_etat_processus)
                                                          .erreur_systeme =
- Line 4526  evaluation(struct_processus *s_etat_proc
+ Line 6526  evaluation(struct_processus *s_etat_proc
                                      if (pthread_mutex_unlock(
                                              &((*(*s_etat_processus)
-                                             .s_liste_variables_partagees)
+                                             .pointeur_variable_partagee_courante
-                                             .mutex)) != 0)
+                                             ).mutex)) != 0)
                                      {
                                          (*s_etat_processus).erreur_systeme =
                                                  d_es_processus;
- Line 4539  evaluation(struct_processus *s_etat_proc
+ Line 6539  evaluation(struct_processus *s_etat_proc
                                      (*s_etat_processus).erreur_systeme = d_es;
                                      presence_variable = 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
                              {
                                  presence_variable = d_vrai;
-                                 if ((*((*s_etat_processus)
+                                 if ((*(*(*s_etat_processus)
-                                         .s_liste_variables
+                                         .pointeur_variable_courante).objet)
-                                         [(*s_etat_processus)
+                                         .type == ADR)
-                                         .position_variable_courante]
-                                         .objet)).type == ADR)
                                  {
                                      presence_fonction = d_vrai;
                                  }
- Line 4648  evaluation(struct_processus *s_etat_proc
+ Line 6636  evaluation(struct_processus *s_etat_proc
                              if (presence_variable_partagee == d_faux)
                              {
                                  (*s_etat_processus).position_courante =
-                                         (*((unsigned long *)
+                                         (*((integer8 *)
-                                         ((*((*s_etat_processus)
+                                         ((*(*(*s_etat_processus)
-                                         .s_liste_variables[(*s_etat_processus)
+                                         .pointeur_variable_courante)
-                                         .position_variable_courante]
+                                         .objet).objet)));
-                                         .objet)).objet)));
                              }
                              else
                              {
                                  (*s_etat_processus).position_courante =
-                                         (*((unsigned long *)
+                                         (*((integer8 *)
                                          (*s_copie_variable_partagee).objet));
                                  liberation(s_etat_processus,
                                          s_copie_variable_partagee);
- Line 4666  evaluation(struct_processus *s_etat_proc
+ Line 6653  evaluation(struct_processus *s_etat_proc
                              if ((*s_etat_processus).profilage == d_vrai)
                              {
                                  profilage(s_etat_processus,
-                                         (*s_etat_processus).s_liste_variables
+                                         (*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).nom);
-                                         .position_variable_courante].nom);
                                  if ((*s_etat_processus).erreur_systeme != d_es)
                                  {
- Line 4695  evaluation(struct_processus *s_etat_proc
+ Line 6681  evaluation(struct_processus *s_etat_proc
                                              s_objet_evalue);
                                  }
+                                 depilement_pile_systeme(s_etat_processus);
                                  (*s_etat_processus).instruction_courante =
                                          instruction_courante;
                                  (*s_etat_processus).mode_execution_programme =
- Line 4703  evaluation(struct_processus *s_etat_proc
+ Line 6691  evaluation(struct_processus *s_etat_proc
                              }
                              (*s_etat_processus).evaluation_forcee =
-                                 registre_evaluation_forcee;
+                                     registre_evaluation_forcee;
                              (*s_etat_processus).instruction_courante =
                                      instruction_courante;
                              (*s_etat_processus).mode_execution_programme = 'N';
- Line 4739  evaluation(struct_processus *s_etat_proc
+ Line 6727  evaluation(struct_processus *s_etat_proc
                              {
                                  if ((s_sous_objet =
                                          copie_objet(s_etat_processus,
-                                         (*s_etat_processus)
+                                         (*(*s_etat_processus)
-                                         .s_liste_variables[(*s_etat_processus)
+                                         .pointeur_variable_courante).objet,
-                                         .position_variable_courante].objet,
                                          'P')) == NULL)
                                  {
                                      if (presence_variable_partagee == d_vrai)
- Line 4810  evaluation(struct_processus *s_etat_proc
+ Line 6797  evaluation(struct_processus *s_etat_proc
                                      (*s_etat_processus)
                                      .evaluation_expression_compilee;
-                             if (((*s_etat_processus).s_liste_variables
+                             if (((*(*s_etat_processus)
-                                     [(*s_etat_processus)
+                                     .pointeur_variable_courante)
-                                     .position_variable_courante].origine == 'E')
+                                     .origine == 'E') && ((*(*s_etat_processus)
-                                     && ((*s_etat_processus).s_liste_variables
+                                     .pointeur_variable_courante).niveau == 0))
-                                     [(*s_etat_processus)
-                                     .position_variable_courante].niveau == 0))
                              {
                                  (*s_etat_processus)
                                          .evaluation_expression_compilee = 'Y';
- Line 4831  evaluation(struct_processus *s_etat_proc
+ Line 6816  evaluation(struct_processus *s_etat_proc
                                  if ((*s_etat_processus).profilage == d_vrai)
                                  {
                                      profilage(s_etat_processus,
-                                             (*s_etat_processus)
+                                             (*(*s_etat_processus)
-                                             .s_liste_variables
+                                             .pointeur_variable_courante).nom);
-                                             [(*s_etat_processus)
-                                             .position_variable_courante].nom);
                                      if ((*s_etat_processus).erreur_systeme
                                              != d_es)
- Line 4843  evaluation(struct_processus *s_etat_proc
+ Line 6826  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)
                                          .retour_definition = 'Y';
                                  (*(*s_etat_processus).l_base_pile_systeme)
                                          .niveau_courant = (*s_etat_processus)
                                          .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,
-                                         (*s_etat_processus)
+                                         (*(*s_etat_processus)
-                                         .s_liste_variables[(*s_etat_processus)
+                                         .pointeur_variable_courante).objet,
-                                         .position_variable_courante].objet,
                                          type_evaluation) == d_erreur)
                                  {
                                      depilement_pile_systeme(s_etat_processus);
-                                     (*(*s_etat_processus).l_base_pile_systeme)
-                                             .niveau_courant =
-                                             registre_niveau_courant;
-                                     (*(*s_etat_processus).l_base_pile_systeme)
-                                             .retour_definition =
-                                             registre_retour_definition;
                                      if ((*s_etat_processus).profilage == d_vrai)
                                      {
                                          profilage(s_etat_processus, NULL);
- Line 4895  evaluation(struct_processus *s_etat_proc
+ Line 6870  evaluation(struct_processus *s_etat_proc
                                  depilement_pile_systeme(s_etat_processus);
+                                 if ((((*s_etat_processus).erreur_execution !=
+                                         d_ex) || ((*s_etat_processus)
+                                         .erreur_systeme != d_es)) &&
+                                         ((*s_etat_processus).arret_si_exception
+                                         == d_faux))
+                                 {
+                                     // Reprise sur erreur.
+ //==============================================================================
+ //  Réindentation
+ //==============================================================================
+             drapeau_then = d_faux;
+             while(drapeau_then == d_faux)
+             {
+                 l_registre_atome = l_element_courant;
+                 l_element_courant = (*l_element_courant).suivant;
+                 if (l_element_courant == NULL)
+                 {
+                     /*
+                      * La fin de l'expression est atteinte,
+                      * le sequenceur reprend la main.
+                      */
+                     if (presence_egalite == d_vrai)
+                     {
+                         liberation(s_etat_processus, s_objet_evalue);
+                     }
+                     (*s_etat_processus).mode_execution_programme =
+                             registre_mode_execution_programme;
+                     return(d_absence_erreur);
+                 }
+                 if ((*(*l_element_courant).donnee).type == FCT)
+                 {
+                     (*s_etat_processus).instruction_courante =
+                             (*((struct_fonction *)
+                             (*(*l_element_courant).donnee)
+                             .objet)).nom_fonction;
+                     if (recherche_variable(s_etat_processus,
+                             (*s_etat_processus).instruction_courante) == d_faux)
+                     {
+                         (*s_etat_processus).erreur_systeme = d_es;
+                         fonction = (*((struct_fonction *)
+                                 (*(*l_element_courant).donnee)
+                                 .objet)).fonction;
+                         /*
+                          * Traitement de la pile système par les
+                          * différentes instructions.
+                          */
+                         if (TEST(instruction_if) ||
+                                 TEST(instruction_iferr) ||
+                                 TEST(instruction_do) ||
+                                 TEST(instruction_while) ||
+                                 TEST(instruction_for) ||
+                                 TEST(instruction_forall) ||
+                                 TEST(instruction_start) ||
+                                 TEST(instruction_select) ||
+                                 TEST(instruction_case) ||
+                                 TEST(instruction_critical) ||
+                                 TEST(vers_niveau_superieur))
+                         {
+                             if (TEST(vers_niveau_superieur))
+                             {
+                                 registre_exception = (*s_etat_processus)
+                                     .exception;
+                                 registre_erreur_execution = (*s_etat_processus)
+                                     .erreur_execution;
+                                 analyse(s_etat_processus,
+                                         vers_niveau_superieur);
+                                 if ((*s_etat_processus).erreur_systeme != d_es)
+                                 {
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 (*s_etat_processus).exception
+                                         = registre_exception;
+                                 (*s_etat_processus).erreur_execution =
+                                     registre_erreur_execution;
+                             }
+                             else if (TEST(instruction_for) ||
+                                     TEST(instruction_forall) ||
+                                     TEST(instruction_start))
+                             {
+                                 empilement_pile_systeme(s_etat_processus);
+                                 if ((*s_etat_processus).erreur_systeme != d_es)
+                                 {
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
                                  (*(*s_etat_processus).l_base_pile_systeme)
-                                         .niveau_courant =
+                                         .type_cloture = 'L';
-                                         registre_niveau_courant;
+                             }
+                             else
+                             {
+                                 empilement_pile_systeme(s_etat_processus);
+                                 if ((*s_etat_processus).erreur_systeme != d_es)
+                                 {
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                             }
+                         }
+                         else if (TEST(instruction_end) ||
+                                 TEST(instruction_next) ||
+                                 TEST(instruction_step) ||
+                                 TEST(vers_niveau_inferieur))
+                         {
+                             if (TEST(vers_niveau_inferieur))
+                             {
+                                 registre_exception = (*s_etat_processus)
+                                         .exception;
+                                 registre_erreur_execution = (*s_etat_processus)
+                                         .erreur_execution;
+                                 analyse(s_etat_processus,
+                                         vers_niveau_inferieur);
+                                 if ((*s_etat_processus).erreur_systeme != d_es)
+                                 {
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                             s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 (*s_etat_processus).exception
+                                         = registre_exception;
+                                 (*s_etat_processus).erreur_execution =
+                                         registre_erreur_execution;
+                             }
+                             else if ((TEST(instruction_next) ||
+                                     TEST(instruction_step)) &&
+                                     ((*(*s_etat_processus)
+                                     .l_base_pile_systeme)
+                                     .type_cloture != 'L'))
+                             {
+                                 /*
+                                  * Libération des compteurs
+                                  * de boucle
+                                  */
+                                 presence_compteur = (((*(*s_etat_processus)
+                                     .l_base_pile_systeme).type_cloture == 'F')
+                                     || ((*(*s_etat_processus)
+                                     .l_base_pile_systeme).type_cloture == 'A'))
+                                     ? d_vrai : d_faux;
+                                 if (((*(*s_etat_processus).l_base_pile_systeme)
+                                     .type_cloture != 'S') && (presence_compteur
+                                     == d_faux))
+                                 {
+                                     (*s_etat_processus).erreur_execution =
+                                             d_ex_erreur_traitement_boucle;
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                             s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 if (presence_compteur == d_vrai)
+                                 {
+                                     if (recherche_variable(s_etat_processus,
+                                             (*(*s_etat_processus)
+                                             .l_base_pile_systeme).nom_variable)
+                                             == d_faux)
+                                     {
+                                         (*s_etat_processus).erreur_systeme =
+                                                 d_es;
+                                         (*s_etat_processus).erreur_execution =
+                                                 d_ex_erreur_traitement_boucle;
+                                         if (presence_egalite == d_vrai)
+                                         {
+                                             liberation(s_etat_processus,
+                                                     s_objet_evalue);
+                                         }
+                                         (*s_etat_processus).instruction_courante
+                                                 = instruction_courante;
+                                         return(d_erreur);
+                                     }
+                                     if ((*(*s_etat_processus)
+                                             .pointeur_variable_courante)
+                                             .objet == NULL)
+                                     {
+                                         (*s_etat_processus).erreur_systeme =
+                                                 d_es;
+                                         (*s_etat_processus).erreur_execution =
+                                                 d_ex_variable_partagee;
+                                         if (presence_egalite == d_vrai)
+                                         {
+                                             liberation(s_etat_processus,
+                                                     s_objet_evalue);
+                                         }
+                                         (*s_etat_processus).instruction_courante
+                                                 = instruction_courante;
+                                         return(d_erreur);
+                                     }
+                                     (*s_etat_processus)
+                                             .niveau_courant--;
+                                     if (retrait_variables_par_niveau(
+                                             s_etat_processus) == d_erreur)
+                                     {
+                                         if (presence_egalite == d_vrai)
+                                         {
+                                             liberation(s_etat_processus,
+                                                     s_objet_evalue);
+                                         }
+                                         (*s_etat_processus).instruction_courante                                                = instruction_courante;
+                                         return(d_erreur);
+                                     }
+                                 }
+                                 depilement_pile_systeme(s_etat_processus);
+                             }
+                             else
+                             {
+                                 // Traitement spécifique pour
+                                 // la fin d'une section
+                                 // critique
+                                 if ((*s_etat_processus).l_base_pile_systeme
+                                         == NULL)
+                                 {
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_end_incoherent;
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                                 if ((*(*s_etat_processus).l_base_pile_systeme)
+                                         .type_cloture == 'Q')
+                                 {
+                                     if (pthread_mutex_unlock(
+                                             &mutex_sections_critiques) != 0)
+                                     {
+                                         (*s_etat_processus).erreur_systeme =
+                                                 d_es_processus;
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                         (*s_etat_processus).instruction_courante                                                = instruction_courante;
+                                         return(d_erreur);
+                                     }
+                                     (*s_etat_processus).sections_critiques--;
+                                 }
+                                 depilement_pile_systeme(s_etat_processus);
+                                 if ((*s_etat_processus)
+                                         .erreur_systeme != d_es)
+                                 {
+                                     if (presence_egalite == d_vrai)
+                                     {
+                                         liberation(s_etat_processus,
+                                                 s_objet_evalue);
+                                     }
+                                     (*s_etat_processus).instruction_courante =
+                                             instruction_courante;
+                                     return(d_erreur);
+                                 }
+                             }
+                         }
+                         else if (TEST(instruction_then))
+                         {
+                             if ((*(*s_etat_processus).l_base_pile_systeme)
+                                     .clause == 'R')
+                             {
                                  (*(*s_etat_processus).l_base_pile_systeme)
-                                         .retour_definition =
+                                         .clause = 'X';
-                                         registre_retour_definition;
+                                 instruction_then(s_etat_processus);
+                                 drapeau_then = d_vrai;
+                             }
+                         }
+                     }
+                 }
+             }
+             (*s_etat_processus).expression_courante =
+                     l_element_courant;
+             (*s_etat_processus).instruction_courante =
+                     instruction_courante;
+             (*s_etat_processus).exception = d_ep;
+             (*s_etat_processus).erreur_execution = d_ex;
+ //==============================================================================
+ //  Fin de la réindentation
+ //==============================================================================
+                                 }
                              }
                              else
                              {
                                  if ((*s_etat_processus).profilage == d_vrai)
                                  {
                                      profilage(s_etat_processus,
-                                             (*s_etat_processus)
+                                             (*(*s_etat_processus)
-                                             .s_liste_variables
+                                             .pointeur_variable_courante).nom);
-                                             [(*s_etat_processus)
-                                             .position_variable_courante].nom);
                                      if ((*s_etat_processus).erreur_systeme
                                              != d_es)
- Line 4925  evaluation(struct_processus *s_etat_proc
+ Line 7244  evaluation(struct_processus *s_etat_proc
                                  (*(*s_etat_processus).l_base_pile_systeme)
                                          .niveau_courant = (*s_etat_processus)
                                          .niveau_courant;
-                                 empilement_pile_systeme(s_etat_processus);
                                  if (evaluation(s_etat_processus,
                                          s_copie_variable_partagee,
                                          type_evaluation) == d_erreur)
                                  {
                                      depilement_pile_systeme(s_etat_processus);
-                                     depilement_pile_systeme(s_etat_processus);
                                      liberation(s_etat_processus,
                                              s_copie_variable_partagee);
- Line 4960  evaluation(struct_processus *s_etat_proc
+ Line 7277  evaluation(struct_processus *s_etat_proc
                                  }
                                  depilement_pile_systeme(s_etat_processus);
-                                 depilement_pile_systeme(s_etat_processus);
                                  liberation(s_etat_processus,
                                          s_copie_variable_partagee);
- Line 5014  evaluation(struct_processus *s_etat_proc
+ Line 7330  evaluation(struct_processus *s_etat_proc
                                      (*((struct_nom *) (*s_objet_elementaire)
                                      .objet)).nom) == d_vrai)
                              {
-                                 if ((*s_etat_processus).s_liste_variables
+                                 if ((*(*s_etat_processus)
-                                         [(*s_etat_processus)
+                                         .pointeur_variable_courante).objet
-                                         .position_variable_courante].objet
                                          == NULL)
                                  {
                                      // 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(
                                              s_etat_processus,
-                                             ((*s_etat_processus)
+                                             (*(*s_etat_processus)
-                                             .s_liste_variables
+                                             .pointeur_variable_courante).nom,
-                                             [(*s_etat_processus)
+                                             (*(*s_etat_processus)
-                                             .position_variable_courante]).nom,
+                                             .pointeur_variable_courante)
-                                             ((*s_etat_processus)
+                                             .variable_partagee, 'E') != NULL)
-                                             .s_liste_variables
-                                             [(*s_etat_processus)
-                                             .position_variable_courante])
-                                             .variable_partagee, 'E') == d_vrai)
                                      {
                                          liberation(s_etat_processus,
                                                  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(
-                                                     &((*(*s_etat_processus)
+                                             &((*(*s_etat_processus)
-                                                     .s_liste_variables_partagees
+                                             .pointeur_variable_partagee_courante
-                                                     ).mutex)) != 0)
+                                             ).mutex)) != 0)
                                              {
                                                  (*s_etat_processus)
                                                          .erreur_systeme =
- Line 5079  evaluation(struct_processus *s_etat_proc
+ Line 7377  evaluation(struct_processus *s_etat_proc
                                                      instruction_courante;
                                              return(d_erreur);
                                          }
-                                     }
-                                     if (pthread_mutex_unlock(
+                                         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 =
-                                                 d_es_processus;
+                                                     d_es_processus;
-                                         return(d_erreur);
+                                             return(d_erreur);
+                                         }
                                      }
                                  }
                                  else
- Line 5100  evaluation(struct_processus *s_etat_proc
+ Line 7398  evaluation(struct_processus *s_etat_proc
                                      if ((s_objet_elementaire =
                                              copie_objet(s_etat_processus,
-                                             (*s_etat_processus)
+                                             (*(*s_etat_processus)
-                                             .s_liste_variables
+                                             .pointeur_variable_courante).objet,
-                                             [(*s_etat_processus)
-                                             .position_variable_courante].objet,
                                              'P')) == NULL)
                                      {
                                          if (presence_egalite == d_vrai)
- Line 5230  evaluation(struct_processus *s_etat_proc
+ Line 7526  evaluation(struct_processus *s_etat_proc
              // 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')
              {
                  registre_expression_courante =
- Line 5271  evaluation(struct_processus *s_etat_proc
+ Line 7552  evaluation(struct_processus *s_etat_proc
                  (*s_etat_processus).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)
- Line 5282  evaluation(struct_processus *s_etat_proc
+ Line 7579  evaluation(struct_processus *s_etat_proc
              (*s_etat_processus).niveau_courant = niveau_initial;
-             for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
+             if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
-             {
-                 if ((*s_etat_processus).s_liste_variables[n].niveau
-                         > niveau_initial)
-                 {
-                     m++;
-                 }
-             }
-             registre_variables = (*s_etat_processus).s_liste_variables;
-             (*s_etat_processus).nombre_variables -= m;
-             if (((*s_etat_processus).s_liste_variables = malloc(
-                     (*s_etat_processus).nombre_variables *
-                     sizeof(struct_variable))) == NULL)
              {
                  if (presence_egalite == d_vrai)
                  {
                      liberation(s_etat_processus, s_objet_evalue);
                  }
-                 (*s_etat_processus).instruction_courante = instruction_courante;
+                 (*s_etat_processus).instruction_courante =
-                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                         instruction_courante;
+                 (*s_etat_processus).mode_execution_programme =
+                         registre_mode_execution_programme;
                  return(d_erreur);
              }
-             for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
-             {
-                 if (registre_variables[n + m].niveau > niveau_initial)
-                 {
-                     free(registre_variables[n + m].nom);
-                     liberation(s_etat_processus,
-                             registre_variables[n + m].objet);
-                     m++;
-                     n--;
-                 }
-                 else
-                 {
-                     (*s_etat_processus).s_liste_variables[n] =
-                             registre_variables[n + m];
-                 }
-             }
-             free(registre_variables);
          }
          /*
           * 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
           */
-         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;
-             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]
+             if (presence_egalite == d_vrai)
-                     .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);
          }
- Line 5439  evaluation(struct_processus *s_etat_proc
+ Line 7662  evaluation(struct_processus *s_etat_proc
                  (*s_etat_processus).autorisation_empilement_programme =
                          autorisation_empilement_programme;
                  (*s_etat_processus).instruction_courante = instruction_courante;
-                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-                         registre_retour_definition;
                  return(d_erreur);
              }
- Line 5454  evaluation(struct_processus *s_etat_proc
+ Line 7674  evaluation(struct_processus *s_etat_proc
                  (*s_etat_processus).autorisation_empilement_programme =
                          autorisation_empilement_programme;
                  (*s_etat_processus).instruction_courante = instruction_courante;
-                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-                         registre_retour_definition;
                  return(d_erreur);
              }
          }
- Line 5464  evaluation(struct_processus *s_etat_proc
+ Line 7681  evaluation(struct_processus *s_etat_proc
          (*s_etat_processus).autorisation_empilement_programme =
                  autorisation_empilement_programme;
          (*s_etat_processus).instruction_courante = instruction_courante;
-         (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
-                 registre_retour_definition;
      }
      else if ((*s_objet).type == FCT)
      {
- Line 5474  evaluation(struct_processus *s_etat_proc
+ Line 7689  evaluation(struct_processus *s_etat_proc
          registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
                  ? 'E' : 'N';
-         cf(s_etat_processus, 35);
+         if (type_evaluation == 'N')
+         {
+             cf(s_etat_processus, 35);
+         }
+         else
+         {
+             sf(s_etat_processus, 35);
+         }
          analyse(s_etat_processus, (*((struct_fonction *)
                  (*s_objet).objet)).fonction);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.31
changed lines
	Added in v.1.99