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

Diff for /rpl/src/evaluation.c between versions 1.11 and 1.120

version 1.11, 2010/04/17 18:57:35 version 1.120, 2025/04/15 10:17:50
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.14    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
 #define DEBUG_RETURN  
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
 #define TEST(instruction) (fonction == instruction)  #define TEST(instruction) (fonction == instruction)
 #define vers_niveau_inferieur instruction_vers_niveau_inferieur  #define vers_niveau_inferieur instruction_vers_niveau_inferieur
Line 48  evaluation(struct_processus *s_etat_proc Line 48  evaluation(struct_processus *s_etat_proc
 {  {
     integer8                        i;      integer8                        i;
     integer8                        j;      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                        drapeau_then;
     logical1                        erreur_evaluation;      logical1                        erreur_evaluation;
       logical1                        presence_compteur;
     logical1                        presence_egalite;      logical1                        presence_egalite;
     logical1                        presence_fonction;      logical1                        presence_fonction;
     logical1                        presence_variable;      logical1                        presence_variable;
Line 76  evaluation(struct_processus *s_etat_proc Line 84  evaluation(struct_processus *s_etat_proc
     struct_objet                    *s_sous_objet;      struct_objet                    *s_sous_objet;
     struct_objet                    *s_copie_variable_partagee;      struct_objet                    *s_copie_variable_partagee;
   
     struct_variable                 *registre_variables;  
   
     unsigned char                   autorisation_empilement_programme;      unsigned char                   autorisation_empilement_programme;
     unsigned char                   *instruction_courante;      unsigned char                   *instruction_courante;
     unsigned char                   *message;      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_evaluation_forcee;
     unsigned char                   registre_instruction_valide;      unsigned char                   registre_instruction_valide;
     unsigned char                   registre_mode_execution_programme;      unsigned char                   registre_mode_execution_programme;
     unsigned char                   registre_retour_definition;  
     unsigned char                   registre_test;      unsigned char                   registre_test;
     unsigned char                   registre_test_2;      unsigned char                   registre_test_2;
     unsigned char                   registre_type_evaluation;      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)();      void                            (*fonction)();
   
Line 143  evaluation(struct_processus *s_etat_proc Line 138  evaluation(struct_processus *s_etat_proc
             if (recherche_variable(s_etat_processus, (*((struct_nom *)              if (recherche_variable(s_etat_processus, (*((struct_nom *)
                     (*s_objet_tampon).objet)).nom) == d_faux)                      (*s_objet_tampon).objet)).nom) == d_faux)
             {              {
                   (*s_etat_processus).erreur_execution = d_ex;
   
                 if ((*s_etat_processus).autorisation_nom_implicite == 'N')                  if ((*s_etat_processus).autorisation_nom_implicite == 'N')
                 {                  {
                     if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==                      if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
                             d_faux)                              d_faux)
                     {                      {
 uprintf("Paf !\n");                          if (test_cfsf(s_etat_processus, 31) == d_vrai)
                           {
                               if (empilement_pile_last(s_etat_processus, 0)
                                       == d_erreur)
                               {
                                   return(d_erreur);
                               }
                           }
   
                           erreur_evaluation = d_erreur;
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_nom_implicite;                                  d_ex_nom_implicite;
                         return(d_erreur);  
                           if (type_evaluation == 'I')
                           {
                               (*s_etat_processus).derniere_erreur_evaluation =
                                       (*s_etat_processus).erreur_execution;
                           }
                     }                      }
                 }                  }
   
Line 162  uprintf("Paf !\n"); Line 173  uprintf("Paf !\n");
             {              {
                 if ((*s_etat_processus).traitement_symbolique == 'N')                  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)                              .objet == NULL)
                     {                      {
                         // Variable partagée                          // Variable partagée
   
                         if (pthread_mutex_lock(&((*(*s_etat_processus)  
                                 .s_liste_variables_partagees).mutex)) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_processus;  
                             return(d_erreur);  
                         }  
   
                         presence_variable_partagee = d_faux;                          presence_variable_partagee = d_faux;
   
                         if (recherche_variable_partagee(s_etat_processus,                          if (recherche_variable_partagee(s_etat_processus,
                                 ((*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 = d_vrai;
                             presence_variable_partagee = d_vrai;                              presence_variable_partagee = d_vrai;
   
                             if ((*((*(*s_etat_processus)                              if ((*(*(*s_etat_processus)
                                     .s_liste_variables_partagees).table                                      .pointeur_variable_partagee_courante).objet)
                                     [(*(*s_etat_processus)                                      .type == ADR)
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet)).type  
                                     == ADR)  
                             {                              {
                                 presence_fonction = d_vrai;                                  presence_fonction = d_vrai;
                             }                              }
Line 203  uprintf("Paf !\n"); Line 200  uprintf("Paf !\n");
                             if ((s_copie_variable_partagee =                              if ((s_copie_variable_partagee =
                                     copie_objet(s_etat_processus,                                      copie_objet(s_etat_processus,
                                     (*(*s_etat_processus)                                      (*(*s_etat_processus)
                                     .s_liste_variables_partagees)                                      .pointeur_variable_partagee_courante).objet,
                                     .table[(*(*s_etat_processus)                                      'P')) == NULL)
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet, 'P')) == NULL)  
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_allocation_memoire;                                          d_es_allocation_memoire;
   
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 224  uprintf("Paf !\n"); Line 219  uprintf("Paf !\n");
                             }                              }
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees).mutex))                                      .pointeur_variable_partagee_courante)
                                     != 0)                                      .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 237  uprintf("Paf !\n"); Line 232  uprintf("Paf !\n");
                             (*s_etat_processus).erreur_systeme = d_es;                              (*s_etat_processus).erreur_systeme = d_es;
                             presence_variable = d_faux;                              presence_variable = d_faux;
                             presence_variable_partagee = d_faux;                              presence_variable_partagee = d_faux;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return(d_erreur);  
                             }  
                         }                          }
                     }                      }
                     else                      else
Line 253  uprintf("Paf !\n"); Line 240  uprintf("Paf !\n");
   
                         presence_variable = d_vrai;                          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;                              presence_fonction = d_vrai;
                         }                          }
Line 299  uprintf("Paf !\n"); Line 285  uprintf("Paf !\n");
                 (*s_etat_processus).autorisation_empilement_programme = 'N';                  (*s_etat_processus).autorisation_empilement_programme = 'N';
   
                 (*(*s_etat_processus).l_base_pile_systeme)                  (*(*s_etat_processus).l_base_pile_systeme)
                         .niveau_courant = (*s_etat_processus)                          .niveau_courant = (*s_etat_processus).niveau_courant;
                         .niveau_courant;  
   
                 if (presence_variable_partagee == d_faux)                  if (presence_variable_partagee == d_faux)
                 {                  {
                     (*s_etat_processus).position_courante =                      (*s_etat_processus).position_courante =
                             (*((unsigned long *)                              (*((integer8 *) ((*(*(*s_etat_processus)
                             ((*((*s_etat_processus).s_liste_variables                              .pointeur_variable_courante).objet).objet)));
                             [(*s_etat_processus)  
                             .position_variable_courante]  
                             .objet)).objet)));  
                 }                  }
                 else                  else
                 {                  {
                     (*s_etat_processus).position_courante =                      (*s_etat_processus).position_courante =
                             (*((unsigned long *) (*s_copie_variable_partagee)                              (*((integer8 *) (*s_copie_variable_partagee)
                             .objet));                              .objet));
                     liberation(s_etat_processus, s_copie_variable_partagee);                      liberation(s_etat_processus, s_copie_variable_partagee);
   
                     if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                             .s_liste_variables_partagees).mutex)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_processus;  
                         return(d_erreur);  
                     }  
                 }                  }
   
                 if ((*s_etat_processus).profilage == d_vrai)                  if ((*s_etat_processus).profilage == d_vrai)
                 {                  {
                     profilage(s_etat_processus,                      profilage(s_etat_processus,
                             (*s_etat_processus).s_liste_variables                              (*(*s_etat_processus).pointeur_variable_courante)
                             [(*s_etat_processus).position_variable_courante]  
                             .nom);                              .nom);
   
                     if ((*s_etat_processus).erreur_systeme != d_es)                      if ((*s_etat_processus).erreur_systeme != d_es)
Line 350  uprintf("Paf !\n"); Line 323  uprintf("Paf !\n");
   
                 if (sequenceur(s_etat_processus) == d_erreur)                  if (sequenceur(s_etat_processus) == d_erreur)
                 {                  {
                       depilement_pile_systeme(s_etat_processus);
   
                     (*s_etat_processus).evaluation_forcee =                      (*s_etat_processus).evaluation_forcee =
                             registre_evaluation_forcee;                              registre_evaluation_forcee;
                     (*s_etat_processus).mode_execution_programme =                      (*s_etat_processus).mode_execution_programme =
Line 383  uprintf("Paf !\n"); Line 358  uprintf("Paf !\n");
                 registre_evaluation_expression_compilee =                  registre_evaluation_expression_compilee =
                         (*s_etat_processus).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';                      (*s_etat_processus).evaluation_expression_compilee = 'Y';
                 }                  }
Line 399  uprintf("Paf !\n"); Line 372  uprintf("Paf !\n");
                 if ((*s_etat_processus).profilage == d_vrai)                  if ((*s_etat_processus).profilage == d_vrai)
                 {                  {
                     profilage(s_etat_processus,                      profilage(s_etat_processus,
                             (*s_etat_processus).s_liste_variables                              (*(*s_etat_processus).pointeur_variable_courante)
                             [(*s_etat_processus).position_variable_courante]  
                             .nom);                              .nom);
   
                     if ((*s_etat_processus).erreur_systeme != d_es)                      if ((*s_etat_processus).erreur_systeme != d_es)
                     {                      {
                         if (presence_variable_partagee == d_vrai)  
                         {  
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return(d_erreur);  
                             }  
                         }  
   
                         return(d_erreur);                          return(d_erreur);
                     }                      }
                 }                  }
   
                   autorisation_empilement_programme = (*s_etat_processus)
                           .autorisation_empilement_programme;
   
                   empilement_pile_systeme(s_etat_processus);
   
                   if ((*s_etat_processus).erreur_systeme != d_es)
                   {
                       if (presence_variable_partagee == d_vrai)
                       {
                           liberation(s_etat_processus, s_copie_variable_partagee);
                       }
   
                       (*s_etat_processus).instruction_courante =
                               instruction_courante;
                       return(d_erreur);
                   }
   
                   (*(*s_etat_processus).l_base_pile_systeme)
                           .retour_definition = 'Y';
                   (*(*s_etat_processus).l_base_pile_systeme)
                           .origine_routine_evaluation = 'Y';
   
                   (*s_etat_processus).mode_execution_programme = 'Y';
                   (*s_etat_processus).autorisation_empilement_programme = 'N';
   
                   (*(*s_etat_processus).l_base_pile_systeme)
                           .niveau_courant = (*s_etat_processus)
                           .niveau_courant;
   
                 if (presence_variable_partagee == d_faux)                  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)                              type_evaluation) == d_erreur)
                     {                       { 
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
Line 432  uprintf("Paf !\n"); Line 421  uprintf("Paf !\n");
                             profilage(s_etat_processus, NULL);                              profilage(s_etat_processus, NULL);
                         }                          }
   
                           depilement_pile_systeme(s_etat_processus);
   
                         (*s_etat_processus).evaluation_expression_compilee =                          (*s_etat_processus).evaluation_expression_compilee =
                                 registre_evaluation_expression_compilee;                                  registre_evaluation_expression_compilee;
   
Line 454  uprintf("Paf !\n"); Line 445  uprintf("Paf !\n");
                             profilage(s_etat_processus, NULL);                              profilage(s_etat_processus, NULL);
                         }                          }
   
                           depilement_pile_systeme(s_etat_processus);
   
                         (*s_etat_processus).evaluation_expression_compilee =                          (*s_etat_processus).evaluation_expression_compilee =
                                 registre_evaluation_expression_compilee;                                  registre_evaluation_expression_compilee;
   
Line 472  uprintf("Paf !\n"); Line 465  uprintf("Paf !\n");
                     profilage(s_etat_processus, NULL);                      profilage(s_etat_processus, NULL);
                 }                  }
   
                   depilement_pile_systeme(s_etat_processus);
   
                   if ((*s_etat_processus).erreur_systeme != d_es)
                   {
                       return(d_erreur);
                   }
   
                 (*s_etat_processus).evaluation_expression_compilee =                  (*s_etat_processus).evaluation_expression_compilee =
                         registre_evaluation_expression_compilee;                          registre_evaluation_expression_compilee;
                   (*s_etat_processus).autorisation_empilement_programme =
                           autorisation_empilement_programme;
             }              }
             else              else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
             {              {
                 if ((s_objet_tampon = copie_objet(s_etat_processus,                  if ((s_objet_tampon = copie_objet(s_etat_processus,
                         s_objet, 'P')) == NULL)                          s_objet, 'Q')) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 496  uprintf("Paf !\n"); Line 498  uprintf("Paf !\n");
                             instruction_courante;                              instruction_courante;
                     return(d_erreur);                      return(d_erreur);
                 }                  }
   
                 if ((*s_etat_processus).erreur_execution ==  
                         d_ex_variable_non_definie)  
                 {  
                     (*s_etat_processus).erreur_execution = d_ex;  
                 }  
             }              }
         }          }
         else          else
Line 717  uprintf("Paf !\n"); Line 713  uprintf("Paf !\n");
          * Exécution de la séquence d'instructions           * 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';  
   
         l_element_courant = (struct_liste_chainee *) (*s_objet).objet;          l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
         autorisation_empilement_programme = (*s_etat_processus)          autorisation_empilement_programme = (*s_etat_processus)
                 .autorisation_empilement_programme;                  .autorisation_empilement_programme;
Line 762  uprintf("Paf !\n"); Line 754  uprintf("Paf !\n");
                             ((*s_etat_processus).erreur_systeme == d_es) &&                              ((*s_etat_processus).erreur_systeme == d_es) &&
                             ((*s_etat_processus).exception == d_ep))                              ((*s_etat_processus).exception == d_ep))
                     {                      {
                           registre_evaluation_expression_compilee =
                                   (*s_etat_processus)
                                   .evaluation_expression_compilee;
   
                           (*s_etat_processus).evaluation_expression_compilee
                                   = 'Y';
   
                         analyse(s_etat_processus, (*((struct_fonction *)                          analyse(s_etat_processus, (*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .fonction);                                  .fonction);
   
                           (*s_etat_processus).evaluation_expression_compilee =
                                   registre_evaluation_expression_compilee;
   
                         if (type_evaluation == 'I')                          if (type_evaluation == 'I')
                         {                          {
                             (*s_etat_processus).derniere_erreur_evaluation =                              (*s_etat_processus).derniere_erreur_evaluation =
Line 783  uprintf("Paf !\n"); Line 785  uprintf("Paf !\n");
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 819  uprintf("Paf !\n"); Line 822  uprintf("Paf !\n");
   
                             free(message);                              free(message);
   
                             while((*(*s_etat_processus).l_base_pile_systeme)                              drapeau_then = d_faux;
                                     .clause != 'R')  
                               while(drapeau_then == d_faux)
                             {                              {
                                 l_registre_atome = l_element_courant;                                  l_registre_atome = l_element_courant;
                                 l_element_courant =                                  l_element_courant =
Line 872  uprintf("Paf !\n"); Line 876  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 892  uprintf("Paf !\n"); Line 898  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 904  uprintf("Paf !\n"); Line 918  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                               }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 947  uprintf("Paf !\n"); Line 989  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 959  uprintf("Paf !\n"); Line 1009  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                             else                                              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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
                                               }
                                               else
                                               {
                                                   // Traitement spécifique pour
                                                   // la fin d'une section
                                                   // critique
   
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .l_base_pile_systeme
                                                           == NULL)
                                                 {                                                  {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                     if (presence_egalite ==                                                      if (presence_egalite ==
                                                             d_vrai)                                                              d_vrai)
                                                     {                                                      {
Line 980  uprintf("Paf !\n"); Line 1158  uprintf("Paf !\n");
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }  
                                         }  
                                     }  
                                 }  
                             }  
   
                             (*s_etat_processus).instruction_courante =                                                  if ((*(*s_etat_processus)
                                     instruction_courante;                                                          .l_base_pile_systeme)
                             drapeau_then = d_faux;                                                          .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                             do                                                          liberation(
                             {                                                          s_etat_processus,
                                 l_registre_atome = l_element_courant;                                                          s_objet_evalue);
   
                                 if (l_element_courant == NULL)                                                          (*s_etat_processus)
                                 {                                                          .instruction_courante =
                                     /*                                                          instruction_courante;
                                      * La fin de l'expression est atteinte,                                                          return(d_erreur);
                                      * le sequenceur reprend la main.                                                      }
                                      */  
   
                                     if (presence_egalite == d_vrai)                                                      (*s_etat_processus)
                                     {                                                          .sections_critiques--;
                                         liberation(s_etat_processus,                                                  }
                                                 s_objet_evalue);  
                                     }  
   
                                     (*s_etat_processus)                                                  depilement_pile_systeme(
                                             .mode_execution_programme =                                                          s_etat_processus);
                                             registre_mode_execution_programme;  
                                     (*s_etat_processus).instruction_courante =  
                                             instruction_courante;  
                                     return(d_absence_erreur);  
                                 }  
   
                                 if ((*(*l_element_courant).donnee).type == FCT)                                                  if ((*s_etat_processus)
                                 {                                                          .erreur_systeme != d_es)
                                     (*s_etat_processus)                                                  {
                                             .instruction_courante =                                                      if (presence_egalite ==
                                             (*((struct_fonction *)                                                              d_vrai)
                                             (*(*l_element_courant).donnee)                                                      {
                                             .objet)).nom_fonction;                                                          liberation(
                                     fonction = (*((struct_fonction *)                                                              s_etat_processus,
                                             (*(*l_element_courant).donnee)                                                              s_objet_evalue);
                                             .objet)).fonction;                                                      }
                                     (*s_etat_processus).instruction_courante =  
                                             instruction_courante;  
   
                                     drapeau_then = TEST(instruction_then)                                                      (*s_etat_processus)
                                             ? d_vrai : d_faux;                                                          .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                           }
                                           else if (TEST(instruction_then))
                                           {
                                               if ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .clause == 'R')
                                               {
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .clause = 'X';
                                                   instruction_then(
                                                           s_etat_processus);
                                                   drapeau_then = d_vrai;
                                               }
                                           }
                                       }
                                 }                                  }
                               }
                                 l_element_courant = (*l_element_courant)  
                                         .suivant;  
                             } while(drapeau_then == d_faux);  
   
                             (*s_etat_processus).expression_courante =                              (*s_etat_processus).expression_courante =
                                     l_registre_atome;                                      l_element_courant;
                               (*s_etat_processus).instruction_courante =
                             (*(*s_etat_processus).l_base_pile_systeme)                                      instruction_courante;
                                     .clause = 'X';  
                             instruction_then(s_etat_processus);  
   
                             (*s_etat_processus).exception = d_ep;                              (*s_etat_processus).exception = d_ep;
                             (*s_etat_processus).erreur_execution = d_ex;                              (*s_etat_processus).erreur_execution = d_ex;
Line 1082  uprintf("Paf !\n"); Line 1268  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1095  uprintf("Paf !\n"); Line 1283  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 1137  uprintf("Paf !\n"); Line 1361  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                             else                                              else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                             {                                              {
                                                   /*
                                                    * 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(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
                                               }
                                               else
                                               {
                                                   // Traitement spécifique pour
                                                   // la fin d'une section
                                                   // critique
   
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .l_base_pile_systeme
                                                           == NULL)
                                                 {                                                  {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                     if (presence_egalite ==                                                      if (presence_egalite ==
                                                             d_vrai)                                                              d_vrai)
                                                     {                                                      {
Line 1164  uprintf("Paf !\n"); Line 1524  uprintf("Paf !\n");
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                               }
   
                                               if ((*s_etat_processus)
                                                       .erreur_systeme != d_es)
                                               {
                                                   if (presence_egalite ==
                                                           d_vrai)
                                                   {
                                                       liberation(
                                                           s_etat_processus,
                                                           s_objet_evalue);
                                                   }
   
                                                   (*s_etat_processus)
                                                       .instruction_courante =
                                                       instruction_courante;
                                                   return(d_erreur);
                                             }                                              }
                                         }                                          }
                                     }                                      }
Line 1235  uprintf("Paf !\n"); Line 1645  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1248  uprintf("Paf !\n"); Line 1660  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 1290  uprintf("Paf !\n"); Line 1738  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .retour_definition
                                                           == 'Y')
                                                   {
                                                       break;
                                                   }
                                               }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                             }                                              }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour
                                                   // la fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme
                                                           == NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 1339  uprintf("Paf !\n"); Line 1980  uprintf("Paf !\n");
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 1650  uprintf("Paf !\n"); Line 2292  uprintf("Paf !\n");
                         return(d_erreur);                          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,                          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.                              // Une variable partagée existe.
   
                             presence_variable_partagee = d_vrai;                              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                          else
                         {                          {
                             presence_variable_partagee = d_faux;                              presence_variable_partagee = d_faux;
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex)) != 0)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                             }  
                         }                          }
                     }                      }
                     else                      else
Line 1704  uprintf("Paf !\n"); Line 2325  uprintf("Paf !\n");
                      * Recherche d'un élément dans un vecteur                       * 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)                              .objet == NULL)
                     {                      {
                         // La variable partagée n'existe plus.                          // La variable partagée n'existe plus.
Line 1718  uprintf("Paf !\n"); Line 2338  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1737  uprintf("Paf !\n"); Line 2356  uprintf("Paf !\n");
                             return(d_erreur);;                              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)                              && ((*((struct_fonction *) (*(*l_element_courant)
                             .donnee).objet)).nombre_arguments == 1))                              .donnee).objet)).nombre_arguments == 1))
                     {                      {
Line 1756  uprintf("Paf !\n"); Line 2372  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1784  uprintf("Paf !\n"); Line 2399  uprintf("Paf !\n");
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                         if ((*s_objet_indice_i).type == INT)                          if ((*s_objet_indice_i).type != INT)
                         {                          {
                             liberation(s_etat_processus, s_objet_indice_i);                              liberation(s_etat_processus, s_objet_indice_i);
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
   
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1824  uprintf("Paf !\n"); Line 2438  uprintf("Paf !\n");
                         liberation(s_etat_processus, s_objet_indice_i);                          liberation(s_etat_processus, s_objet_indice_i);
   
                         if ((i < 1) || (i > (integer8) (*((struct_vecteur *)                          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))                                  .taille))
                         {                          {
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
   
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 1861  uprintf("Paf !\n"); Line 2473  uprintf("Paf !\n");
                             return(d_erreur);                              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)                                  == VIN)
                         {                          {
                             if (((*s_objet_elementaire).objet = malloc(sizeof(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1877  uprintf("Paf !\n"); Line 2488  uprintf("Paf !\n");
   
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 1902  uprintf("Paf !\n"); Line 2512  uprintf("Paf !\n");
                             (*s_objet_elementaire).type = INT;                              (*s_objet_elementaire).type = INT;
                             (*((integer8 *) (*s_objet_elementaire).objet)) =                              (*((integer8 *) (*s_objet_elementaire).objet)) =
                                     ((integer8 *) (*((struct_vecteur *)                                      ((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];                                      .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)                                  == VRL)
                         {                          {
                             if (((*s_objet_elementaire).objet = malloc(sizeof(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1917  uprintf("Paf !\n"); Line 2525  uprintf("Paf !\n");
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 1948  uprintf("Paf !\n"); Line 2555  uprintf("Paf !\n");
                             (*s_objet_elementaire).type = REL;                              (*s_objet_elementaire).type = REL;
                             (*((real8 *) (*s_objet_elementaire).objet)) =                              (*((real8 *) (*s_objet_elementaire).objet)) =
                                     ((real8 *) (*((struct_vecteur *)                                      ((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];                                      .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)                                  == VCX)
                         {                          {
                             if (((*s_objet_elementaire).objet = malloc(sizeof(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 1963  uprintf("Paf !\n"); Line 2568  uprintf("Paf !\n");
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 1995  uprintf("Paf !\n"); Line 2599  uprintf("Paf !\n");
                             (*((struct_complexe16 *) (*s_objet_elementaire)                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                     .objet)).partie_reelle =                                      .objet)).partie_reelle =
                                     ((struct_complexe16 *) (*((struct_vecteur *)                                      ((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)                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                     .objet)).partie_imaginaire =                                      .objet)).partie_imaginaire =
                                     ((struct_complexe16 *) (*((struct_vecteur *)                                      ((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 2015  uprintf("Paf !\n"); Line 2615  uprintf("Paf !\n");
                      * Recherche d'un élément dans une matrice                       * 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)                              && ((*((struct_fonction *) (*(*l_element_courant)
                             .donnee).objet)).nombre_arguments == 2))                              .donnee).objet)).nombre_arguments == 2))
                     {                      {
Line 2034  uprintf("Paf !\n"); Line 2631  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2071  uprintf("Paf !\n"); Line 2667  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2109  uprintf("Paf !\n"); Line 2704  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2145  uprintf("Paf !\n"); Line 2739  uprintf("Paf !\n");
                         liberation(s_etat_processus, s_objet_indice_j);                          liberation(s_etat_processus, s_objet_indice_j);
   
                         if ((i < 1) || (i > (integer8) (*((struct_matrice *)                          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)                                  .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))                                  .nombre_colonnes))
                         {                          {
                             liberation(s_etat_processus, s_objet_indice_i);  
                             liberation(s_etat_processus, s_objet_indice_j);  
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
   
                             if (presence_variable_partagee == d_vrai)                              if (presence_variable_partagee == d_vrai)
                             {                              {
                                 (*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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2189  uprintf("Paf !\n"); Line 2778  uprintf("Paf !\n");
                             return(d_erreur);                              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(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
                                     integer8))) == NULL)                                      integer8))) == NULL)
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2230  uprintf("Paf !\n"); Line 2816  uprintf("Paf !\n");
                             (*s_objet_elementaire).type = INT;                              (*s_objet_elementaire).type = INT;
                             (*((integer8 *) (*s_objet_elementaire).objet)) =                              (*((integer8 *) (*s_objet_elementaire).objet)) =
                                     ((integer8 **) (*((struct_matrice *)                                      ((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];                                      .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)                                  == MRL)
                         {                          {
                             if (((*s_objet_elementaire).objet = malloc(sizeof(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 2245  uprintf("Paf !\n"); Line 2829  uprintf("Paf !\n");
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2276  uprintf("Paf !\n"); Line 2859  uprintf("Paf !\n");
                             (*s_objet_elementaire).type = REL;                              (*s_objet_elementaire).type = REL;
                             (*((real8 *) (*s_objet_elementaire).objet)) =                              (*((real8 *) (*s_objet_elementaire).objet)) =
                                     ((real8 **) (*((struct_matrice *)                                      ((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];                                      .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)                                  == MCX)
                         {                          {
                             if (((*s_objet_elementaire).objet = malloc(sizeof(                              if (((*s_objet_elementaire).objet = malloc(sizeof(
Line 2291  uprintf("Paf !\n"); Line 2872  uprintf("Paf !\n");
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2324  uprintf("Paf !\n"); Line 2904  uprintf("Paf !\n");
                                     .objet)).partie_reelle =                                      .objet)).partie_reelle =
                                     ((struct_complexe16 **)                                      ((struct_complexe16 **)
                                     (*((struct_matrice *)                                      (*((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]                                      .objet)).tableau)[i - 1][j - 1]
                                     .partie_reelle;                                      .partie_reelle;
                             (*((struct_complexe16 *) (*s_objet_elementaire)                              (*((struct_complexe16 *) (*s_objet_elementaire)
                                     .objet)).partie_imaginaire =                                      .objet)).partie_imaginaire =
                                     ((struct_complexe16 **)                                      ((struct_complexe16 **)
                                     (*((struct_matrice *)                                      (*((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]                                      .objet)).tableau)[i - 1][j - 1]
                                     .partie_imaginaire;                                      .partie_imaginaire;
                         }                          }
Line 2345  uprintf("Paf !\n"); Line 2923  uprintf("Paf !\n");
                      * Recherche de l'élément idoine dans la liste                       * 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)                              ((*((struct_fonction *) (*(*l_element_courant)
                             .donnee).objet)).nombre_arguments == 1))                              .donnee).objet)).nombre_arguments == 1))
                     {                      {
Line 2358  uprintf("Paf !\n"); Line 2935  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2394  uprintf("Paf !\n"); Line 2970  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2427  uprintf("Paf !\n"); Line 3002  uprintf("Paf !\n");
   
                         liberation(s_etat_processus, s_objet_indice_i);                          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;                          j = 0;
   
                         while(l_sous_element_courant != NULL)                          while(l_sous_element_courant != NULL)
Line 2449  uprintf("Paf !\n"); Line 3023  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2486  uprintf("Paf !\n"); Line 3059  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2512  uprintf("Paf !\n"); Line 3084  uprintf("Paf !\n");
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              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                       * 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)                              ((*((struct_fonction *) (*(*l_element_courant)
                             .donnee).objet)).nombre_arguments == 1))                              .donnee).objet)).nombre_arguments == 1))
                     {                      {
Line 2531  uprintf("Paf !\n"); Line 3182  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2567  uprintf("Paf !\n"); Line 3217  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2601  uprintf("Paf !\n"); Line 3250  uprintf("Paf !\n");
                         liberation(s_etat_processus, s_objet_indice_i);                          liberation(s_etat_processus, s_objet_indice_i);
   
                         if ((i < 1) || (i > (integer8) (*((struct_tableau *)                          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))                                  .objet)).nombre_elements))
                         {                          {
                             free(s_objet_elementaire);                              free(s_objet_elementaire);
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2643  uprintf("Paf !\n"); Line 3290  uprintf("Paf !\n");
   
                         if ((s_objet_elementaire =                          if ((s_objet_elementaire =
                                 copie_objet(s_etat_processus,                                  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)                                  .objet)).elements[i - 1], 'P')) == NULL)
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2676  uprintf("Paf !\n"); Line 3321  uprintf("Paf !\n");
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              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 =                          registre_evaluation_expression_compilee =
                                 (*s_etat_processus)                                  (*s_etat_processus)
                                 .evaluation_expression_compilee;                                  .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 =                              (*s_etat_processus).evaluation_expression_compilee =
                                     'Y';                                      'Y';
Line 2704  uprintf("Paf !\n"); Line 3424  uprintf("Paf !\n");
                                     'N';                                      '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)                                  type_evaluation) == d_erreur)
                         {                          {
                             (*s_etat_processus).evaluation_expression_compilee =                              (*s_etat_processus).evaluation_expression_compilee =
Line 2714  uprintf("Paf !\n"); Line 3433  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2752  uprintf("Paf !\n"); Line 3470  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2781  uprintf("Paf !\n"); Line 3498  uprintf("Paf !\n");
                             return(d_erreur);                              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 = (*s_etat_processus)
                                 .autorisation_empilement_programme;                                  .autorisation_empilement_programme;
Line 2796  uprintf("Paf !\n"); Line 3512  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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(                                  if (pthread_mutex_unlock(
                                         &((*(*s_etat_processus)                                          &((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2816  uprintf("Paf !\n"); Line 3531  uprintf("Paf !\n");
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
                             }                              }
   
                               depilement_pile_systeme(s_etat_processus);
   
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              return(d_erreur);
Line 2835  uprintf("Paf !\n"); Line 3552  uprintf("Paf !\n");
                                 .niveau_courant;                                  .niveau_courant;
   
                         (*s_etat_processus).position_courante =                          (*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)                          if ((*s_etat_processus).profilage == d_vrai)
                         {                          {
                             profilage(s_etat_processus,                              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 ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                 if (presence_variable_partagee == d_vrai)                                  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(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 2886  uprintf("Paf !\n"); Line 3598  uprintf("Paf !\n");
   
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2905  uprintf("Paf !\n"); Line 3616  uprintf("Paf !\n");
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
                             }                              }
   
                               depilement_pile_systeme(s_etat_processus);
   
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             (*s_etat_processus).mode_execution_programme =                              (*s_etat_processus).mode_execution_programme =
Line 2924  uprintf("Paf !\n"); Line 3637  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees)                                          .pointeur_variable_partagee_courante)
                                         .mutex)) != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 2960  uprintf("Paf !\n"); Line 3672  uprintf("Paf !\n");
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              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)                                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                         .s_liste_variables_partagees).mutex))                                          .pointeur_variable_partagee_courante)
                                         != 0)                                          .mutex)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
Line 2992  uprintf("Paf !\n"); Line 3703  uprintf("Paf !\n");
                     {                      {
                         if (presence_variable_partagee == d_vrai)                          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)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees) .mutex)) != 0)                                      .pointeur_variable_partagee_courante)
                                       .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 3025  uprintf("Paf !\n"); Line 3736  uprintf("Paf !\n");
                     {                      {
                         if (presence_variable_partagee == d_vrai)                          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)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees).mutex)) != 0)                                      .pointeur_variable_partagee_courante)
                                       .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
Line 3050  uprintf("Paf !\n"); Line 3761  uprintf("Paf !\n");
   
                     if (presence_variable_partagee == d_vrai)                      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)                          if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                 .s_liste_variables_partagees).mutex)) != 0)                                  .pointeur_variable_partagee_courante).mutex))
                                   != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_processus;                                      d_es_processus;
Line 3108  uprintf("Paf !\n"); Line 3818  uprintf("Paf !\n");
                                 .evaluation_expression_compilee;                                  .evaluation_expression_compilee;
   
                         (*s_etat_processus).evaluation_expression_compilee                          (*s_etat_processus).evaluation_expression_compilee
                                 = 'N';                                  = 'Y';
   
                         if (evaluation(s_etat_processus, (*l_element_courant)                          if (evaluation(s_etat_processus, (*l_element_courant)
                                 .donnee, type_evaluation) == d_erreur)                                  .donnee, type_evaluation) == d_erreur)
Line 3218  uprintf("Paf !\n"); Line 3928  uprintf("Paf !\n");
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 3307  uprintf("Paf !\n"); Line 4018  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3327  uprintf("Paf !\n"); Line 4040  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3339  uprintf("Paf !\n"); Line 4060  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                               }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 3382  uprintf("Paf !\n"); Line 4131  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3394  uprintf("Paf !\n"); Line 4151  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                               }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3427  uprintf("Paf !\n"); Line 4361  uprintf("Paf !\n");
   
                             do                              do
                             {                              {
                                   l_element_courant = (*l_element_courant)
                                           .suivant;
                                 l_registre_atome = l_element_courant;                                  l_registre_atome = l_element_courant;
   
                                 if (l_element_courant == NULL)                                  if (l_element_courant == NULL)
Line 3466  uprintf("Paf !\n"); Line 4402  uprintf("Paf !\n");
                                     drapeau_then = TEST(instruction_then)                                      drapeau_then = TEST(instruction_then)
                                             ? d_vrai : d_faux;                                              ? d_vrai : d_faux;
                                 }                                  }
   
                                 l_element_courant = (*l_element_courant)  
                                         .suivant;  
                             } while(drapeau_then == d_faux);                              } while(drapeau_then == d_faux);
   
                             (*s_etat_processus).expression_courante =                              (*s_etat_processus).expression_courante =
Line 3517  uprintf("Paf !\n"); Line 4450  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3530  uprintf("Paf !\n"); Line 4465  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 3572  uprintf("Paf !\n"); Line 4543  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                             }                                              }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3667  uprintf("Paf !\n"); Line 4823  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3680  uprintf("Paf !\n"); Line 4838  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                               }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 3722  uprintf("Paf !\n"); Line 4916  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                             }                                              }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3771  uprintf("Paf !\n"); Line 5150  uprintf("Paf !\n");
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 3799  uprintf("Paf !\n"); Line 5179  uprintf("Paf !\n");
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 3835  uprintf("Paf !\n"); Line 5216  uprintf("Paf !\n");
   
                             free(message);                              free(message);
   
                               l_registre_atome = l_element_courant;
   
                             while((*(*s_etat_processus).l_base_pile_systeme)                              while((*(*s_etat_processus).l_base_pile_systeme)
                                     .clause != 'R')                                      .clause != 'R')
                             {                              {
Line 3888  uprintf("Paf !\n"); Line 5271  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3908  uprintf("Paf !\n"); Line 5293  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3920  uprintf("Paf !\n"); Line 5313  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                               }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 3963  uprintf("Paf !\n"); Line 5384  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3975  uprintf("Paf !\n"); Line 5404  uprintf("Paf !\n");
                                                     .erreur_execution =                                                      .erreur_execution =
                                                     registre_erreur_execution;                                                      registre_erreur_execution;
                                             }                                              }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                               }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4008  uprintf("Paf !\n"); Line 5614  uprintf("Paf !\n");
   
                             do                              do
                             {                              {
                                   (*s_etat_processus).expression_courante =
                                           l_registre_atome;
                                 l_registre_atome = l_element_courant;                                  l_registre_atome = l_element_courant;
   
                                 if (l_element_courant == NULL)                                  if (l_element_courant == NULL)
Line 4052  uprintf("Paf !\n"); Line 5660  uprintf("Paf !\n");
                                         .suivant;                                          .suivant;
                             } while(drapeau_then == d_faux);                              } while(drapeau_then == d_faux);
   
                             (*s_etat_processus).expression_courante =  
                                     l_registre_atome;  
   
                             (*(*s_etat_processus).l_base_pile_systeme)                              (*(*s_etat_processus).l_base_pile_systeme)
                                     .clause = 'X';                                      .clause = 'X';
                             instruction_then(s_etat_processus);                              instruction_then(s_etat_processus);
Line 4098  uprintf("Paf !\n"); Line 5703  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 4111  uprintf("Paf !\n"); Line 5718  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                               }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 4153  uprintf("Paf !\n"); Line 5796  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                               }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4248  uprintf("Paf !\n"); Line 6076  uprintf("Paf !\n");
                                                 TEST(instruction_do) ||                                                  TEST(instruction_do) ||
                                                 TEST(instruction_while) ||                                                  TEST(instruction_while) ||
                                                 TEST(instruction_for) ||                                                  TEST(instruction_for) ||
                                                   TEST(instruction_forall) ||
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 4261  uprintf("Paf !\n"); Line 6091  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                               else if (TEST(instruction_for) ||
                                                       TEST(instruction_forall) ||
                                                       TEST(instruction_start))
                                               {
                                                   empilement_pile_systeme(
                                                           s_etat_processus);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture = 'L';
                                               }
                                             else                                              else
                                             {                                              {
                                                 empilement_pile_systeme(                                                  empilement_pile_systeme(
Line 4303  uprintf("Paf !\n"); Line 6169  uprintf("Paf !\n");
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
                                                     return(d_erreur);                                                      return(d_erreur);
                                                 }                                                  }
                                             }                                              }
                                               else if ((TEST(instruction_next) ||
                                                       TEST(instruction_step)) &&
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'L'))
                                               {
                                                   /*
                                                    * Libération des compteurs
                                                    * de boucle
                                                    */
   
                                                   presence_compteur =
                                                       (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'F') ||
                                                       ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture == 'A'))
                                                       ? d_vrai : d_faux;
   
                                                   if (((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .type_cloture != 'S') &&
                                                       (presence_compteur ==
                                                       d_faux))
                                                   {
                                                       (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if (presence_compteur == d_vrai)
                                                   {
                                                       if (recherche_variable(
                                                           s_etat_processus,
                                                           (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .nom_variable) ==
                                                           d_faux)
                                                       {
                                                           (*s_etat_processus)
                                                   .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                   .erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       if ((*(*s_etat_processus)
                                                       .pointeur_variable_courante)
                                                       .objet == NULL)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme = d_es;
                                                           (*s_etat_processus)
                                                           .erreur_execution =
                                                           d_ex_variable_partagee;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .niveau_courant--;
   
                                                       if (
                                                   retrait_variables_par_niveau(
                                                   s_etat_processus) == d_erreur)
                                                       {
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                   depilement_pile_systeme(
                                                           s_etat_processus);
                                               }
                                             else                                              else
                                             {                                              {
                                                   // Traitement spécifique pour la
                                                   // fin d'une section critique
   
                                                   if ((*s_etat_processus)
                                                           .l_base_pile_systeme ==
                                                           NULL)
                                                   {
                                                       (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .type_cloture == 'Q')
                                                   {
                                                       if (pthread_mutex_unlock(
                                                       &mutex_sections_critiques)
                                                       != 0)
                                                       {
                                                           (*s_etat_processus)
                                                           .erreur_systeme =
                                                           d_es_processus;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4343  uprintf("Paf !\n"); Line 6394  uprintf("Paf !\n");
                                     registre_mode_execution_programme;                                      registre_mode_execution_programme;
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
   
                             if (presence_egalite == d_vrai)                              if (presence_egalite == d_vrai)
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
Line 4352  uprintf("Paf !\n"); Line 6402  uprintf("Paf !\n");
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 4402  uprintf("Paf !\n"); Line 6453  uprintf("Paf !\n");
                             if ((*((struct_nom *) (*s_objet_elementaire).objet))                              if ((*((struct_nom *) (*s_objet_elementaire).objet))
                                     .symbole == d_faux)                                      .symbole == d_faux)
                             {                              {
 uprintf("Pif\n");                                  if (test_cfsf(s_etat_processus, 31) == d_vrai)
                                   {
                                       if (empilement_pile_last(s_etat_processus,
                                               0) == d_erreur)
                                       {
                                           return(d_erreur);
                                       }
                                   }
   
                                   erreur_evaluation = d_erreur;
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_nom_implicite;                                          d_ex_nom_implicite;
   
 /*                                  if (type_evaluation == 'I')
 ================================================================================                                  {
   Reprise sur erreur                                      (*s_etat_processus)
   Réindentation du code                                              .derniere_erreur_evaluation =
 ================================================================================                                              (*s_etat_processus)
 */                                              .erreur_execution;
                                   }
 if ((*s_etat_processus).arret_si_exception == d_faux)  
 {  
 uprintf("(*s_etat_processus).arret_si_exception == d_faux\n");  
     /*  
      * Reprise sur erreur  
      */  
   
     if ((message = messages(s_etat_processus)) == NULL)  
     {  
         if (presence_egalite == d_vrai)  
         {  
             liberation(s_etat_processus,  
                     s_objet_evalue);  
         }  
   
         (*s_etat_processus).instruction_courante =  
                 instruction_courante;  
         return(d_erreur);  
     }  
   
     free(message);  
   
     while((*(*s_etat_processus).l_base_pile_systeme)  
             .clause != 'R')  
     {  
         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_start) ||  
                         TEST(instruction_select) ||  
                         TEST(instruction_case) ||  
                         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)  
                         {  
                             (*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  
                     {  
                         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)  
                         {  
                             (*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  
                     {  
                         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);  
                         }  
                     }  
                 }  
             }  
         }  
     }  
   
     (*s_etat_processus).instruction_courante = instruction_courante;  
     drapeau_then = d_faux;  
   
     do  
     {  
         l_registre_atome = l_element_courant;  
   
         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;  
             (*s_etat_processus).instruction_courante = instruction_courante;  
             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;  
             fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)  
                     .objet)).fonction;  
             (*s_etat_processus).instruction_courante = instruction_courante;  
   
             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 = l_registre_atome;  
   
     (*(*s_etat_processus).l_base_pile_systeme).clause = 'X';  
     instruction_then(s_etat_processus);  
   
     (*s_etat_processus).exception = d_ep;  
     (*s_etat_processus).erreur_execution = d_ex;  
 }  
 else if ((*s_etat_processus).mode_evaluation_expression == 'Y')  
 {  
 uprintf("(*s_etat_processus).mode_evaluation_expression == 'Y'\n");  
     /*  
      * Reprise sur erreur  
      */  
   
     while(l_element_courant != NULL)  
     {  
         if ((*(*l_element_courant).donnee).type == FCT)  
         {  
             (*s_etat_processus).instruction_courante = (*((struct_fonction *)  
                     (*(*l_element_courant).donnee).objet)).nom_fonction;  
             fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)  
                     .objet)).fonction;  
   
             if (recherche_variable(s_etat_processus, (*s_etat_processus)  
                     .instruction_courante) == d_faux)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es;  
   
                 /*  
                  * Traitement de la pile système par les  
                  * différentes instructions.  
                  */  
   
                 if (TEST(instruction_if) ||  
                         TEST(instruction_iferr) ||  
                         TEST(instruction_do) ||  
                         TEST(instruction_while) ||  
                         TEST(instruction_for) ||  
                         TEST(instruction_start) ||  
                         TEST(instruction_select) ||  
                         TEST(instruction_case) ||  
                         TEST(vers_niveau_superieur))  
                 {  
                     if (TEST(vers_niveau_superieur))  
                     {  
                         analyse(s_etat_processus, vers_niveau_superieur);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                     else  
                     {  
                         empilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             if (presence_egalite == d_vrai)  
                             {  
                                 liberation(s_etat_processus, s_objet_evalue);  
                             }  
   
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                 }  
                 else if (TEST(instruction_end) ||  
                         TEST(instruction_next) ||  
                         TEST(instruction_step) ||  
                         TEST(vers_niveau_inferieur))  
                 {  
                     if (TEST(vers_niveau_inferieur))  
                     {  
                         analyse(s_etat_processus, vers_niveau_inferieur);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                     else  
                     {  
                         depilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             if (presence_egalite == d_vrai)  
                             {  
                                 liberation(s_etat_processus,  
                                         s_objet_evalue);  
                             }  
   
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                 }  
             }  
         }  
   
         l_element_courant = (*l_element_courant).suivant;  
     }  
   
     (*s_etat_processus).mode_execution_programme =  
             registre_mode_execution_programme;  
     (*s_etat_processus).instruction_courante = instruction_courante;  
   
     (*s_etat_processus).exception = d_ep;  
     (*s_etat_processus).erreur_execution = d_ex;  
   
     erreur_evaluation = d_erreur;  
 }  
 else  
 {  
 uprintf("Default\n");  
     // On ne détruit pas les variables pour les inclure  
     // dans le fichier rpl-core.  
   
     (*s_etat_processus).gel_liste_variables = d_vrai;  
   
     registre_erreur_execution = (*s_etat_processus).erreur_execution;  
     registre_exception = (*s_etat_processus).exception;  
     registre_erreur_systeme = (*s_etat_processus).erreur_systeme;  
   
     (*s_etat_processus).s_objet_errone = s_objet;  
     (*s_etat_processus).s_objet_erreur = (*l_element_courant).donnee;  
   
     l_element_courant = (*l_element_courant).suivant;  
   
     while(l_element_courant != NULL)  
     {  
         if ((*(*l_element_courant).donnee).type == FCT)  
         {  
             (*s_etat_processus).instruction_courante = (*((struct_fonction *)  
                     (*(*l_element_courant).donnee).objet)).nom_fonction;  
             fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)  
                     .objet)).fonction;  
   
             if (recherche_variable(s_etat_processus, (*s_etat_processus)  
                     .instruction_courante) == d_faux)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es;  
   
                 /*  
                  * Traitement de la pile système par les  
                  * différentes instructions.  
                  */  
   
                 if (TEST(instruction_if) ||  
                         TEST(instruction_iferr) ||  
                         TEST(instruction_do) ||  
                         TEST(instruction_while) ||  
                         TEST(instruction_for) ||  
                         TEST(instruction_start) ||  
                         TEST(instruction_select) ||  
                         TEST(instruction_case) ||  
                         TEST(vers_niveau_superieur))  
                 {  
                     if (TEST(vers_niveau_superieur))  
                     {  
                         analyse(s_etat_processus, vers_niveau_superieur);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                     else  
                     {  
                         empilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             if (presence_egalite == d_vrai)  
                             {  
                                 liberation(s_etat_processus,  
                                         s_objet_evalue);  
                             }  
   
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                 }  
                 else if (TEST(instruction_end) ||  
                         TEST(instruction_next) ||  
                         TEST(instruction_step) ||  
                         TEST(vers_niveau_inferieur))  
                 {  
                     if (TEST(vers_niveau_inferieur))  
                     {  
                         analyse(s_etat_processus, vers_niveau_inferieur);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                     else  
                     {  
                         depilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             if (presence_egalite == d_vrai)  
                             {  
                                 liberation(s_etat_processus, s_objet_evalue);  
                             }  
   
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
                     }  
                 }  
             }  
         }  
   
         l_element_courant = (*l_element_courant).suivant;  
     }  
   
     (*s_etat_processus).mode_execution_programme =  
             registre_mode_execution_programme;  
     (*s_etat_processus).instruction_courante = instruction_courante;  
   
     if (presence_egalite == d_vrai)  
     {  
         liberation(s_etat_processus, s_objet_evalue);  
     }  
   
     if ((*s_etat_processus).var_volatile_processus_pere == 0)  
     {  
         kill((*s_etat_processus).pid_processus_pere, SIGALRM);  
     }  
     else  
     {  
         (*s_etat_processus).var_volatile_alarme = -1;  
     }  
   
     (*s_etat_processus).erreur_execution = registre_erreur_execution;  
     (*s_etat_processus).erreur_systeme = registre_erreur_systeme;  
     (*s_etat_processus).exception = registre_exception;  
 printf("%d\n", (*s_etat_processus).erreur_execution);  
 printf("<%d>\n", (*s_etat_processus).invalidation_message_erreur);  
     return(d_erreur);  
 }  
   
 /*  
 ================================================================================  
   Fin de la réindentation  
 ================================================================================  
 */  
   
                             }                              }
                         }                          }
                     }                      }
Line 4881  printf("<%d>\n", (*s_etat_processus).inv Line 6480  printf("<%d>\n", (*s_etat_processus).inv
                     {                      {
                         if ((*s_etat_processus).traitement_symbolique == 'N')                          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                                  // Variable partagée
   
                                 if (pthread_mutex_lock(&((*(*s_etat_processus)  
                                         .s_liste_variables_partagees).mutex))  
                                         != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return(d_erreur);  
                                 }  
   
                                 presence_variable_partagee = d_faux;                                  presence_variable_partagee = d_faux;
   
                                 if (recherche_variable_partagee(                                  if (recherche_variable_partagee(
                                         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 = d_vrai;
                                     presence_variable_partagee = d_vrai;                                      presence_variable_partagee = d_vrai;
   
                                     if ((*((*(*s_etat_processus)                                      if ((*(*(*s_etat_processus)
                                             .s_liste_variables_partagees).table                                              .pointeur_variable_partagee_courante
                                             [(*(*s_etat_processus)                                              ).objet).type == ADR)
                                             .s_liste_variables_partagees)  
                                             .position_variable].objet)).type  
                                             == ADR)  
                                     {                                      {
                                         presence_fonction = d_vrai;                                          presence_fonction = d_vrai;
                                     }                                      }
Line 4927  printf("<%d>\n", (*s_etat_processus).inv Line 6510  printf("<%d>\n", (*s_etat_processus).inv
                                             .objet)).symbole == d_faux))                                              .objet)).symbole == d_faux))
                                     {                                      {
                                         if ((s_copie_variable_partagee =                                          if ((s_copie_variable_partagee =
                                                 copie_objet(s_etat_processus,                                              copie_objet(s_etat_processus,
                                                 (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                                 .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                                 .table[(*(*s_etat_processus)                                              ).objet, 'P')) == NULL)
                                                 .s_liste_variables_partagees)  
                                                 .position_variable].objet, 'P'))  
                                                 == NULL)  
                                         {                                          {
                                             if (pthread_mutex_unlock(                                              if (pthread_mutex_unlock(
                                                     &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                                     .s_liste_variables_partagees                                              .pointeur_variable_partagee_courante
                                                     ).mutex)) != 0)                                              ).mutex)) != 0)
                                             {                                              {
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
                                                         .erreur_systeme =                                                          .erreur_systeme =
Line 4954  printf("<%d>\n", (*s_etat_processus).inv Line 6534  printf("<%d>\n", (*s_etat_processus).inv
   
                                     if (pthread_mutex_unlock(                                      if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                      {
                                         (*s_etat_processus).erreur_systeme =                                          (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                  d_es_processus;
Line 4967  printf("<%d>\n", (*s_etat_processus).inv Line 6547  printf("<%d>\n", (*s_etat_processus).inv
                                     (*s_etat_processus).erreur_systeme = d_es;                                      (*s_etat_processus).erreur_systeme = d_es;
                                     presence_variable = d_faux;                                      presence_variable = d_faux;
                                     presence_variable_partagee = d_faux;                                      presence_variable_partagee = d_faux;
   
                                     if (pthread_mutex_unlock(  
                                             &((*(*s_etat_processus)  
                                             .s_liste_variables_partagees)  
                                             .mutex)) != 0)  
                                     {  
                                         (*s_etat_processus).erreur_systeme =  
                                                 d_es_processus;  
                                         return(d_erreur);  
                                     }  
                                 }                                  }
                             }                              }
                             else                              else
                             {                              {
                                 presence_variable = d_vrai;                                  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;                                      presence_fonction = d_vrai;
                                 }                                  }
Line 5003  printf("<%d>\n", (*s_etat_processus).inv Line 6571  printf("<%d>\n", (*s_etat_processus).inv
   
                     if (presence_fonction == d_vrai)                      if (presence_fonction == d_vrai)
                     {                      {
                         autorisation_empilement_programme = (*s_etat_processus)                          if ((*((struct_nom *) (*(*l_element_courant).donnee)
                                 .autorisation_empilement_programme;                                  .objet)).symbole == d_vrai)
                         registre_position_courante = (*s_etat_processus)  
                                 .position_courante;  
   
                         empilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {                          {
                             if (presence_variable_partagee == d_vrai)                              // L'objet apparaît comme un symbole dans
                               // l'expression en cours d'évaluation. On se
                               // contente de l'empiler.
   
                               if ((s_sous_objet = copie_objet(s_etat_processus,
                                       (*l_element_courant).donnee, 'P')) == NULL)
                             {                              {
                                 liberation(s_etat_processus,                                  (*s_etat_processus).instruction_courante =
                                         s_copie_variable_partagee);                                          instruction_courante;
   
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return(d_erreur);
                             }                              }
   
                             if (presence_egalite == d_vrai)                              if (empilement(s_etat_processus,
                                       &((*s_etat_processus).l_base_pile),
                                       s_sous_objet) == d_erreur)
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  (*s_etat_processus).instruction_courante =
                                           instruction_courante;
                                   liberation(s_etat_processus, s_sous_objet);
                                   return(d_erreur);
                             }                              }
   
                             (*s_etat_processus).instruction_courante =  
                                     instruction_courante;  
                             return(d_erreur);  
                         }  
   
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .retour_definition = 'Y';  
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .origine_routine_evaluation = 'Y';  
   
                         (*s_etat_processus).mode_execution_programme = 'Y';  
                         (*s_etat_processus).autorisation_empilement_programme  
                                 = 'N';  
   
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .niveau_courant = (*s_etat_processus)  
                                 .niveau_courant;  
   
                         if (presence_variable_partagee == d_faux)  
                         {  
                             (*s_etat_processus).position_courante =  
                                     (*((unsigned long *)  
                                     ((*((*s_etat_processus).s_liste_variables  
                                     [(*s_etat_processus)  
                                     .position_variable_courante]  
                                     .objet)).objet)));  
                         }                          }
                         else                          else
                         {                          {
                             (*s_etat_processus).position_courante =                              autorisation_empilement_programme =
                                     (*((unsigned long *)                                      (*s_etat_processus)
                                     (*s_copie_variable_partagee).objet));                                      .autorisation_empilement_programme;
                             liberation(s_etat_processus,                              registre_position_courante = (*s_etat_processus)
                                     s_copie_variable_partagee);                                      .position_courante;
                         }  
   
                         if ((*s_etat_processus).profilage == d_vrai)                              empilement_pile_systeme(s_etat_processus);
                         {  
                             profilage(s_etat_processus,  
                                     (*s_etat_processus).s_liste_variables  
                                     [(*s_etat_processus)  
                                     .position_variable_courante].nom);  
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                   if (presence_variable_partagee == d_vrai)
                                   {
                                       liberation(s_etat_processus,
                                               s_copie_variable_partagee);
                                   }
   
                                   if (presence_egalite == d_vrai)
                                   {
                                       liberation(s_etat_processus,
                                               s_objet_evalue);
                                   }
   
                                   (*s_etat_processus).instruction_courante =
                                           instruction_courante;
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
                         }  
   
                         registre_evaluation_forcee =                              (*(*s_etat_processus).l_base_pile_systeme)
                                 (*s_etat_processus).evaluation_forcee;                                      .retour_definition = 'Y';
                               (*(*s_etat_processus).l_base_pile_systeme)
                                       .origine_routine_evaluation = 'Y';
   
                         if (type_evaluation == 'N')                              (*s_etat_processus).mode_execution_programme = 'Y';
                         {                              (*s_etat_processus)
                             (*s_etat_processus).evaluation_forcee = 'Y';                                      .autorisation_empilement_programme = 'N';
                         }  
   
                         if (sequenceur(s_etat_processus) == d_erreur)                              (*(*s_etat_processus).l_base_pile_systeme)
                         {                                      .niveau_courant = (*s_etat_processus)
                             (*s_etat_processus).evaluation_forcee =                                      .niveau_courant;
                                 registre_evaluation_forcee;  
   
                             if (presence_egalite == d_vrai)                              if (presence_variable_partagee == d_faux)
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  (*s_etat_processus).position_courante =
                                           (*((integer8 *)
                                           ((*(*(*s_etat_processus)
                                           .pointeur_variable_courante)
                                           .objet).objet)));
                               }
                               else
                               {
                                   (*s_etat_processus).position_courante =
                                           (*((integer8 *)
                                           (*s_copie_variable_partagee).objet));
                                   liberation(s_etat_processus,
                                           s_copie_variable_partagee);
                               }
   
                               if ((*s_etat_processus).profilage == d_vrai)
                               {
                                   profilage(s_etat_processus,
                                           (*(*s_etat_processus)
                                           .pointeur_variable_courante).nom);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       return(d_erreur);
                                   }
                               }
   
                               registre_evaluation_forcee =
                                       (*s_etat_processus).evaluation_forcee;
   
                               if (type_evaluation == 'N')
                               {
                                   (*s_etat_processus).evaluation_forcee = 'Y';
                               }
   
                               if (sequenceur(s_etat_processus) == d_erreur)
                               {
                                   (*s_etat_processus).evaluation_forcee =
                                       registre_evaluation_forcee;
   
                                   if (presence_egalite == d_vrai)
                                   {
                                       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 =
                                           registre_mode_execution_programme;
                                   return(d_erreur);
                             }                              }
   
                               (*s_etat_processus).evaluation_forcee =
                                       registre_evaluation_forcee;
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             (*s_etat_processus).mode_execution_programme =                              (*s_etat_processus).mode_execution_programme = 'N';
                                     registre_mode_execution_programme;  
                             return(d_erreur);  
                         }  
   
                         (*s_etat_processus).evaluation_forcee =  
                             registre_evaluation_forcee;  
                         (*s_etat_processus).instruction_courante =  
                                 instruction_courante;  
                         (*s_etat_processus).mode_execution_programme = 'N';  
   
                         depilement_pile_systeme(s_etat_processus);                              depilement_pile_systeme(s_etat_processus);
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
                         {  
                             if (presence_egalite == d_vrai)  
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  if (presence_egalite == d_vrai)
                                   {
                                       liberation(s_etat_processus,
                                               s_objet_evalue);
                                   }
   
                                   return(d_erreur);
                             }                              }
   
                             return(d_erreur);                              (*s_etat_processus).retour_routine_evaluation = 'N';
                               (*s_etat_processus).position_courante =
                                       registre_position_courante;
                               (*s_etat_processus)
                                       .autorisation_empilement_programme =
                                       autorisation_empilement_programme;
                         }                          }
   
                         (*s_etat_processus).retour_routine_evaluation = 'N';  
                         (*s_etat_processus).position_courante =  
                                 registre_position_courante;  
                         (*s_etat_processus).autorisation_empilement_programme =  
                                 autorisation_empilement_programme;  
                     }                      }
                     else if (((type_evaluation == 'N') || ((*((struct_nom *)                      else if (((type_evaluation == 'N') || ((*((struct_nom *)
                             (*(*l_element_courant).donnee).objet)).symbole ==                              (*(*l_element_courant).donnee).objet)).symbole ==
Line 5131  printf("<%d>\n", (*s_etat_processus).inv Line 6735  printf("<%d>\n", (*s_etat_processus).inv
                             {                              {
                                 if ((s_sous_objet =                                  if ((s_sous_objet =
                                         copie_objet(s_etat_processus,                                          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)                                          'P')) == NULL)
                                 {                                  {
                                     if (presence_variable_partagee == d_vrai)                                      if (presence_variable_partagee == d_vrai)
Line 5202  printf("<%d>\n", (*s_etat_processus).inv Line 6805  printf("<%d>\n", (*s_etat_processus).inv
                                     (*s_etat_processus)                                      (*s_etat_processus)
                                     .evaluation_expression_compilee;                                      .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)                                  (*s_etat_processus)
                                         .evaluation_expression_compilee = 'Y';                                          .evaluation_expression_compilee = 'Y';
Line 5223  printf("<%d>\n", (*s_etat_processus).inv Line 6824  printf("<%d>\n", (*s_etat_processus).inv
                                 if ((*s_etat_processus).profilage == d_vrai)                                  if ((*s_etat_processus).profilage == d_vrai)
                                 {                                  {
                                     profilage(s_etat_processus,                                      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                                      if ((*s_etat_processus).erreur_systeme
                                             != d_es)                                              != d_es)
Line 5235  printf("<%d>\n", (*s_etat_processus).inv Line 6834  printf("<%d>\n", (*s_etat_processus).inv
                                     }                                      }
                                 }                                  }
   
                                 registre_niveau_courant = (*(*s_etat_processus)                                  empilement_pile_systeme(s_etat_processus);
                                         .l_base_pile_systeme).niveau_courant;  
                                 registre_retour_definition =  
                                         (*(*s_etat_processus)  
                                         .l_base_pile_systeme).retour_definition;  
   
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .retour_definition = 'Y';                                          .retour_definition = 'Y';
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant = (*s_etat_processus)                                          .niveau_courant = (*s_etat_processus)
                                         .niveau_courant;                                          .niveau_courant;
                                 empilement_pile_systeme(s_etat_processus);                                  (*(*s_etat_processus).l_base_pile_systeme)
                                           .pointeur_objet_retour =
                                           l_element_courant;
                                   (*(*s_etat_processus).l_base_pile_systeme)
                                           .origine_routine_evaluation = 'Y';
   
                                 if (evaluation(s_etat_processus,                                  if (evaluation(s_etat_processus,
                                         (*s_etat_processus)                                          (*(*s_etat_processus)
                                         .s_liste_variables[(*s_etat_processus)                                          .pointeur_variable_courante).objet,
                                         .position_variable_courante].objet,  
                                         type_evaluation) == d_erreur)                                          type_evaluation) == d_erreur)
                                 {                                  {
                                     depilement_pile_systeme(s_etat_processus);                                      depilement_pile_systeme(s_etat_processus);
   
                                     (*(*s_etat_processus).l_base_pile_systeme)  
                                             .niveau_courant =  
                                     (*(*s_etat_processus).l_base_pile_systeme)  
                                             .retour_definition =  
                                             registre_retour_definition;  
   
                                     if ((*s_etat_processus).profilage == d_vrai)                                      if ((*s_etat_processus).profilage == d_vrai)
                                     {                                      {
                                         profilage(s_etat_processus, NULL);                                          profilage(s_etat_processus, NULL);
Line 5286  printf("<%d>\n", (*s_etat_processus).inv Line 6878  printf("<%d>\n", (*s_etat_processus).inv
   
                                 depilement_pile_systeme(s_etat_processus);                                  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)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant =                                          .type_cloture = 'L';
                               }
                               else
                               {
                                   empilement_pile_systeme(s_etat_processus);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                           else if (TEST(instruction_end) ||
                                   TEST(instruction_next) ||
                                   TEST(instruction_step) ||
                                   TEST(vers_niveau_inferieur))
                           {
                               if (TEST(vers_niveau_inferieur))
                               {
                                   registre_exception = (*s_etat_processus)
                                           .exception;
                                   registre_erreur_execution = (*s_etat_processus)
                                           .erreur_execution;
   
                                   analyse(s_etat_processus,
                                           vers_niveau_inferieur);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                               s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   (*s_etat_processus).exception
                                           = registre_exception;
                                   (*s_etat_processus).erreur_execution =
                                           registre_erreur_execution;
                               }
                               else if ((TEST(instruction_next) ||
                                       TEST(instruction_step)) &&
                                       ((*(*s_etat_processus)
                                       .l_base_pile_systeme)
                                       .type_cloture != 'L'))
                               {
                                   /*
                                    * Libération des compteurs
                                    * de boucle
                                    */
   
                                   presence_compteur = (((*(*s_etat_processus)
                                       .l_base_pile_systeme).type_cloture == 'F')
                                       || ((*(*s_etat_processus)
                                       .l_base_pile_systeme).type_cloture == 'A'))
                                       ? d_vrai : d_faux;
   
                                   if (((*(*s_etat_processus).l_base_pile_systeme)
                                       .type_cloture != 'S') && (presence_compteur
                                       == d_faux))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_erreur_traitement_boucle;
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                               s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   if (presence_compteur == d_vrai)
                                   {
                                       if (recherche_variable(s_etat_processus,
                                               (*(*s_etat_processus)
                                               .l_base_pile_systeme).nom_variable)
                                               == d_faux)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es;
                                           (*s_etat_processus).erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante
                                                   = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       if ((*(*s_etat_processus)
                                               .pointeur_variable_courante)
                                               .objet == NULL)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es;
                                           (*s_etat_processus).erreur_execution =
                                                   d_ex_variable_partagee;
   
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante
                                                   = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       (*s_etat_processus)
                                               .niveau_courant--;
   
                                       if (retrait_variables_par_niveau(
                                               s_etat_processus) == d_erreur)
                                       {
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante                                                = instruction_courante;
                                           return(d_erreur);
                                       }
                                   }
   
                                   depilement_pile_systeme(s_etat_processus);
                               }
                               else
                               {
                                   // Traitement spécifique pour
                                   // la fin d'une section
                                   // critique
   
                                   if ((*s_etat_processus).l_base_pile_systeme
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_end_incoherent;
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   if ((*(*s_etat_processus).l_base_pile_systeme)
                                           .type_cloture == 'Q')
                                   {
                                       if (pthread_mutex_unlock(
                                               &mutex_sections_critiques) != 0)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_processus;
   
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
   
                                           (*s_etat_processus).instruction_courante                                                = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       (*s_etat_processus).sections_critiques--;
                                   }
   
                                   depilement_pile_systeme(s_etat_processus);
   
                                   if ((*s_etat_processus)
                                           .erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                           else if (TEST(instruction_then))
                           {
                               if ((*(*s_etat_processus).l_base_pile_systeme)
                                       .clause == 'R')
                               {
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*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                              else
                             {                              {
                                 if ((*s_etat_processus).profilage == d_vrai)                                  if ((*s_etat_processus).profilage == d_vrai)
                                 {                                  {
                                     profilage(s_etat_processus,                                      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                                      if ((*s_etat_processus).erreur_systeme
                                             != d_es)                                              != d_es)
Line 5315  printf("<%d>\n", (*s_etat_processus).inv Line 7252  printf("<%d>\n", (*s_etat_processus).inv
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant = (*s_etat_processus)                                          .niveau_courant = (*s_etat_processus)
                                         .niveau_courant;                                          .niveau_courant;
                                 empilement_pile_systeme(s_etat_processus);  
   
                                 if (evaluation(s_etat_processus,                                  if (evaluation(s_etat_processus,
                                         s_copie_variable_partagee,                                          s_copie_variable_partagee,
                                         type_evaluation) == d_erreur)                                          type_evaluation) == d_erreur)
                                 {                                  {
                                     depilement_pile_systeme(s_etat_processus);                                      depilement_pile_systeme(s_etat_processus);
                                     depilement_pile_systeme(s_etat_processus);  
   
                                     liberation(s_etat_processus,                                      liberation(s_etat_processus,
                                             s_copie_variable_partagee);                                              s_copie_variable_partagee);
Line 5350  printf("<%d>\n", (*s_etat_processus).inv Line 7285  printf("<%d>\n", (*s_etat_processus).inv
                                 }                                  }
   
                                 depilement_pile_systeme(s_etat_processus);                                  depilement_pile_systeme(s_etat_processus);
                                 depilement_pile_systeme(s_etat_processus);  
   
                                 liberation(s_etat_processus,                                  liberation(s_etat_processus,
                                         s_copie_variable_partagee);                                          s_copie_variable_partagee);
Line 5404  printf("<%d>\n", (*s_etat_processus).inv Line 7338  printf("<%d>\n", (*s_etat_processus).inv
                                     (*((struct_nom *) (*s_objet_elementaire)                                      (*((struct_nom *) (*s_objet_elementaire)
                                     .objet)).nom) == d_vrai)                                      .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)                                          == NULL)
                                 {                                  {
                                     // Variable partagée                                      // Variable partagée
   
                                     if (pthread_mutex_lock(  
                                             &((*(*s_etat_processus)  
                                             .s_liste_variables_partagees)  
                                             .mutex)) != 0)  
                                     {  
                                         (*s_etat_processus).erreur_systeme =  
                                                 d_es_processus;  
                                         return(d_erreur);  
                                     }  
   
                                     if (recherche_variable_partagee(                                      if (recherche_variable_partagee(
                                             s_etat_processus,                                              s_etat_processus,
                                             ((*s_etat_processus)                                              (*(*s_etat_processus)
                                             .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,                                          liberation(s_etat_processus,
                                                 s_objet_elementaire);                                                  s_objet_elementaire);
   
                                         if ((s_objet_elementaire =                                          if ((s_objet_elementaire =
                                                 copie_objet(s_etat_processus,                                              copie_objet(s_etat_processus,
                                                 (*(*s_etat_processus)                                              (*(*s_etat_processus)
                                                 .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                                 .table[(*(*s_etat_processus)                                              ).objet, 'P')) == NULL)
                                                 .s_liste_variables_partagees)  
                                                 .position_variable].objet,  
                                                 'P')) == NULL)  
                                         {                                          {
                                             if (pthread_mutex_unlock(                                              if (pthread_mutex_unlock(
                                                     &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                                     .s_liste_variables_partagees                                              .pointeur_variable_partagee_courante
                                                     ).mutex)) != 0)                                              ).mutex)) != 0)
                                             {                                              {
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
                                                         .erreur_systeme =                                                          .erreur_systeme =
Line 5469  printf("<%d>\n", (*s_etat_processus).inv Line 7385  printf("<%d>\n", (*s_etat_processus).inv
                                                     instruction_courante;                                                      instruction_courante;
                                             return(d_erreur);                                              return(d_erreur);
                                         }                                          }
                                     }  
   
                                     if (pthread_mutex_unlock(                                          if (pthread_mutex_unlock(
                                             &((*(*s_etat_processus)                                              &((*(*s_etat_processus)
                                             .s_liste_variables_partagees)                                              .pointeur_variable_partagee_courante
                                             .mutex)) != 0)                                              ).mutex)) != 0)
                                     {                                          {
                                         (*s_etat_processus).erreur_systeme =                                              (*s_etat_processus).erreur_systeme =
                                                 d_es_processus;                                                      d_es_processus;
                                         return(d_erreur);                                              return(d_erreur);
                                           }
                                     }                                      }
                                 }                                  }
                                 else                                  else
Line 5490  printf("<%d>\n", (*s_etat_processus).inv Line 7406  printf("<%d>\n", (*s_etat_processus).inv
   
                                     if ((s_objet_elementaire =                                      if ((s_objet_elementaire =
                                             copie_objet(s_etat_processus,                                              copie_objet(s_etat_processus,
                                             (*s_etat_processus)                                              (*(*s_etat_processus)
                                             .s_liste_variables                                              .pointeur_variable_courante).objet,
                                             [(*s_etat_processus)  
                                             .position_variable_courante].objet,  
                                             'P')) == NULL)                                              'P')) == NULL)
                                     {                                      {
                                         if (presence_egalite == d_vrai)                                          if (presence_egalite == d_vrai)
Line 5620  printf("<%d>\n", (*s_etat_processus).inv Line 7534  printf("<%d>\n", (*s_etat_processus).inv
   
             // Traitement de l'instruction EXIT en mode interactif              // Traitement de l'instruction EXIT en mode interactif
   
             if (l_element_courant != NULL)  
             {  
                 l_element_courant = (*l_element_courant).suivant;  
             }  
             else  
             {  
                 (*s_etat_processus).mode_execution_programme = 'Y';  
   
                 if ((*s_etat_processus).niveau_courant == 1)  
                 {  
                     (*s_etat_processus).debug_programme = d_faux;  
                     (*s_etat_processus).execution_pas_suivant = d_vrai;  
                 }  
             }  
   
             if ((*s_etat_processus).traitement_cycle_exit != 'N')              if ((*s_etat_processus).traitement_cycle_exit != 'N')
             {              {
                 registre_expression_courante =                  registre_expression_courante =
Line 5661  printf("<%d>\n", (*s_etat_processus).inv Line 7560  printf("<%d>\n", (*s_etat_processus).inv
                 (*s_etat_processus).expression_courante =                  (*s_etat_processus).expression_courante =
                         registre_expression_courante;                          registre_expression_courante;
             }              }
   
               if (l_element_courant != NULL)
               {
                   l_element_courant = (*l_element_courant).suivant;
               }
               else
               {
                   (*s_etat_processus).mode_execution_programme = 'Y';
   
                   if ((*s_etat_processus).niveau_courant == 1)
                   {
                       (*s_etat_processus).debug_programme = d_faux;
                       (*s_etat_processus).execution_pas_suivant = d_vrai;
                   }
               }
   
         }          }
   
         if (niveau_initial < (*s_etat_processus).niveau_courant)          if (niveau_initial < (*s_etat_processus).niveau_courant)
Line 5672  printf("<%d>\n", (*s_etat_processus).inv Line 7587  printf("<%d>\n", (*s_etat_processus).inv
   
             (*s_etat_processus).niveau_courant = niveau_initial;              (*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)                  if (presence_egalite == d_vrai)
                 {                  {
                     liberation(s_etat_processus, s_objet_evalue);                      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);                  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           * Retrait des variables statiques créées dans l'expression
          */           */
   
         for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)          if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
         {          {
             if ((*s_etat_processus).s_liste_variables_statiques[n]              if (presence_egalite == d_vrai)
                     .niveau > (*s_etat_processus).niveau_courant)  
             {              {
                 if (retrait_variable_statique(s_etat_processus,                  liberation(s_etat_processus, s_objet_evalue);
                         (*s_etat_processus).s_liste_variables_statiques[n].nom,  
                         (*s_etat_processus).s_liste_variables_statiques[n]  
                         .variable_statique) == d_erreur)  
                 {  
                     if (presence_egalite == d_vrai)  
                     {  
                         liberation(s_etat_processus, s_objet_evalue);  
                     }  
   
                     (*s_etat_processus).instruction_courante =  
                             instruction_courante;  
                     (*s_etat_processus).mode_execution_programme =  
                             registre_mode_execution_programme;  
                     return(d_erreur);  
                 }  
             }              }
   
               (*s_etat_processus).instruction_courante =
                       instruction_courante;
               (*s_etat_processus).mode_execution_programme =
                       registre_mode_execution_programme;
               return(d_erreur);
         }          }
   
         /*          /*
          * Retrait des variables partagées créées dans l'expression           * Retrait des variables partagées créées dans l'expression
          */           */
   
         if (pthread_mutex_lock(&((*(*s_etat_processus)          if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
                 .s_liste_variables_partagees).mutex)) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             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);              return(d_erreur);
         }          }
   
Line 5829  printf("<%d>\n", (*s_etat_processus).inv Line 7670  printf("<%d>\n", (*s_etat_processus).inv
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         autorisation_empilement_programme;                          autorisation_empilement_programme;
                 (*s_etat_processus).instruction_courante = instruction_courante;                  (*s_etat_processus).instruction_courante = instruction_courante;
                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =  
                         registre_retour_definition;  
   
                 return(d_erreur);                  return(d_erreur);
             }              }
   
Line 5844  printf("<%d>\n", (*s_etat_processus).inv Line 7682  printf("<%d>\n", (*s_etat_processus).inv
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         autorisation_empilement_programme;                          autorisation_empilement_programme;
                 (*s_etat_processus).instruction_courante = instruction_courante;                  (*s_etat_processus).instruction_courante = instruction_courante;
                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =  
                         registre_retour_definition;  
   
                 return(d_erreur);                  return(d_erreur);
             }              }
         }          }
Line 5854  printf("<%d>\n", (*s_etat_processus).inv Line 7689  printf("<%d>\n", (*s_etat_processus).inv
         (*s_etat_processus).autorisation_empilement_programme =          (*s_etat_processus).autorisation_empilement_programme =
                 autorisation_empilement_programme;                  autorisation_empilement_programme;
         (*s_etat_processus).instruction_courante = instruction_courante;          (*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)      else if ((*s_objet).type == FCT)
     {      {
         (*s_etat_processus).instruction_courante =           (*s_etat_processus).instruction_courante = 
                 (*((struct_fonction *) (*s_objet).objet)).nom_fonction;                  (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
   
           registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
                   ? 'E' : 'N';
   
           if (type_evaluation == 'N')
           {
               cf(s_etat_processus, 35);
           }
           else
           {
               sf(s_etat_processus, 35);
           }
   
         analyse(s_etat_processus, (*((struct_fonction *)          analyse(s_etat_processus, (*((struct_fonction *)
                 (*s_objet).objet)).fonction);                  (*s_objet).objet)).fonction);
   
         (*s_etat_processus).instruction_courante = instruction_courante;          (*s_etat_processus).instruction_courante = instruction_courante;
   
           if (registre_type_evaluation == 'E')
           {
               sf(s_etat_processus, 35);
           }
           else
           {
               cf(s_etat_processus, 35);
           }
   
         if (((*s_etat_processus).erreur_systeme != d_es) ||          if (((*s_etat_processus).erreur_systeme != d_es) ||
                 ((*s_etat_processus).erreur_execution != d_ex) ||                  ((*s_etat_processus).erreur_execution != d_ex) ||
                 ((*s_etat_processus).exception != d_ep))                  ((*s_etat_processus).exception != d_ep))
         {          {
             (*s_etat_processus).instruction_courante = instruction_courante;  
             (*s_etat_processus).mode_execution_programme =              (*s_etat_processus).mode_execution_programme =
                     registre_mode_execution_programme;                      registre_mode_execution_programme;
             return(d_erreur);              return(d_erreur);
Line 5879  printf("<%d>\n", (*s_etat_processus).inv Line 7731  printf("<%d>\n", (*s_etat_processus).inv
     }      }
     else      else
     {      {
           (*s_etat_processus).instruction_courante = instruction_courante;
   
         if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))          if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
                 == NULL)                  == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             (*s_etat_processus).instruction_courante = instruction_courante;  
             return(d_erreur);              return(d_erreur);
         }          }
   
         if (empilement(s_etat_processus, &((*s_etat_processus)          if (empilement(s_etat_processus, &((*s_etat_processus)
                 .l_base_pile), s_objet_tampon) == d_erreur)                  .l_base_pile), s_objet_tampon) == d_erreur)
         {          {
             (*s_etat_processus).instruction_courante = instruction_courante;  
             return(d_erreur);              return(d_erreur);
         }          }
     }      }
Removed from v.1.11  
changed lines
  Added in v.1.120

CVSweb interface <joel.bertrand@systella.fr>