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

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

version 1.1, 2010/01/26 15:22:44 version 1.31, 2011/01/03 12:08:03
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.9    RPL/2 (R) version 4.0.20
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #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 82  evaluation(struct_processus *s_etat_proc Line 82  evaluation(struct_processus *s_etat_proc
     unsigned char                   *instruction_courante;      unsigned char                   *instruction_courante;
     unsigned char                   *message;      unsigned char                   *message;
     unsigned char                   registre_evaluation_expression_compilee;      unsigned char                   registre_evaluation_expression_compilee;
       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_retour_definition;
Line 142  evaluation(struct_processus *s_etat_proc Line 143  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 ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
                               d_faux)
                       {
                           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 =
                                   d_ex_nom_implicite;
   
                           if (type_evaluation == 'I')
                           {
                               (*s_etat_processus).derniere_erreur_evaluation =
                                       (*s_etat_processus).erreur_execution;
                           }
                       }
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es;                  (*s_etat_processus).erreur_systeme = d_es;
                 presence_variable = d_faux;                  presence_variable = d_faux;
             }              }
Line 327  evaluation(struct_processus *s_etat_proc Line 356  evaluation(struct_processus *s_etat_proc
                     }                      }
                 }                  }
   
                   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)                  if (sequenceur(s_etat_processus) == d_erreur)
                 {                  {
                       (*s_etat_processus).evaluation_forcee =
                               registre_evaluation_forcee;
                     (*s_etat_processus).mode_execution_programme =                      (*s_etat_processus).mode_execution_programme =
                             registre_mode_execution_programme;                              registre_mode_execution_programme;
                     (*s_etat_processus).instruction_courante =                      (*s_etat_processus).instruction_courante =
Line 336  evaluation(struct_processus *s_etat_proc Line 375  evaluation(struct_processus *s_etat_proc
                     return(d_erreur);                      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 = 'N';                  (*s_etat_processus).mode_execution_programme = 'N';
Line 395  evaluation(struct_processus *s_etat_proc Line 436  evaluation(struct_processus *s_etat_proc
                     }                      }
                 }                  }
   
                   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;
   
                   empilement_pile_systeme(s_etat_processus);
   
                 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)
Line 447  evaluation(struct_processus *s_etat_proc Line 519  evaluation(struct_processus *s_etat_proc
                     profilage(s_etat_processus, NULL);                      profilage(s_etat_processus, NULL);
                 }                  }
   
                   depilement_pile_systeme(s_etat_processus);
                   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 471  evaluation(struct_processus *s_etat_proc Line 553  evaluation(struct_processus *s_etat_proc
                             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 695  evaluation(struct_processus *s_etat_proc Line 771  evaluation(struct_processus *s_etat_proc
         registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)          registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
                 .retour_definition;                  .retour_definition;
         (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';          (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
           (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
                   s_objet;
   
         l_element_courant = (struct_liste_chainee *) (*s_objet).objet;          l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
         autorisation_empilement_programme = (*s_etat_processus)          autorisation_empilement_programme = (*s_etat_processus)
Line 794  evaluation(struct_processus *s_etat_proc Line 872  evaluation(struct_processus *s_etat_proc
   
                             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 864  evaluation(struct_processus *s_etat_proc Line 943  evaluation(struct_processus *s_etat_proc
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_superieur);                                                          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                                                  (*s_etat_processus).exception
                                                     = registre_exception;                                                      = registre_exception;
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
Line 910  evaluation(struct_processus *s_etat_proc Line 998  evaluation(struct_processus *s_etat_proc
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_inferieur);                                                          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                                                  (*s_etat_processus).exception
                                                     = registre_exception;                                                      = registre_exception;
                                                 (*s_etat_processus)                                                  (*s_etat_processus)
Line 939  evaluation(struct_processus *s_etat_proc Line 1036  evaluation(struct_processus *s_etat_proc
                                                 }                                                  }
                                             }                                              }
                                         }                                          }
                                           else if (TEST(instruction_then))
                                           {
                                               if ((*(*s_etat_processus)
                                                       .l_base_pile_systeme)
                                                       .clause == 'R')
                                               {
                                                   (*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .clause = 'X';
                                                   instruction_then(
                                                           s_etat_processus);
                                                   drapeau_then = d_vrai;
                                               }
                                           }
                                     }                                      }
                                 }                                  }
                             }                              }
   
                               (*s_etat_processus).expression_courante =
                                       l_element_courant;
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     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).exception = d_ep;
                             (*s_etat_processus).erreur_execution = d_ex;                              (*s_etat_processus).erreur_execution = d_ex;
Line 1048  evaluation(struct_processus *s_etat_proc Line 1107  evaluation(struct_processus *s_etat_proc
                                             {                                              {
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_superieur);                                                          vers_niveau_superieur);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 1081  evaluation(struct_processus *s_etat_proc Line 1149  evaluation(struct_processus *s_etat_proc
                                             {                                              {
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_inferieur);                                                          vers_niveau_inferieur);
                                             }  
                                             else  
                                             {  
                                                 depilement_pile_systeme(  
                                                         s_etat_processus);  
   
                                                 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
                                               {
                                                   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 1183  evaluation(struct_processus *s_etat_proc Line 1260  evaluation(struct_processus *s_etat_proc
                                             {                                              {
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_superieur);                                                          vers_niveau_superieur);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 1216  evaluation(struct_processus *s_etat_proc Line 1302  evaluation(struct_processus *s_etat_proc
                                             {                                              {
                                                 analyse(s_etat_processus,                                                  analyse(s_etat_processus,
                                                         vers_niveau_inferieur);                                                          vers_niveau_inferieur);
   
                                                   if ((*s_etat_processus)
                                                           .erreur_systeme != d_es)
                                                   {
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       return(d_erreur);
                                                   }
   
                                                   if ((*(*s_etat_processus)
                                                           .l_base_pile_systeme)
                                                           .retour_definition
                                                           == 'Y')
                                                   {
                                                       break;
                                                   }
                                             }                                              }
                                             else                                              else
                                             {                                              {
Line 2792  evaluation(struct_processus *s_etat_proc Line 2895  evaluation(struct_processus *s_etat_proc
                             }                              }
                         }                          }
   
                           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)                          if (sequenceur(s_etat_processus) == d_erreur)
                         {                          {
                               (*s_etat_processus).evaluation_forcee =
                                       registre_evaluation_forcee;
   
                             if (presence_variable_partagee == d_vrai)                              if (presence_variable_partagee == d_vrai)
                             {                              {
                                 (*s_etat_processus).s_liste_variables                                  (*s_etat_processus).s_liste_variables
Line 2822  evaluation(struct_processus *s_etat_proc Line 2936  evaluation(struct_processus *s_etat_proc
                             return(d_erreur);                              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 = 'N';                          (*s_etat_processus).mode_execution_programme = 'N';
Line 3091  evaluation(struct_processus *s_etat_proc Line 3207  evaluation(struct_processus *s_etat_proc
                     registre_test_2 = (*s_etat_processus).test_instruction;                      registre_test_2 = (*s_etat_processus).test_instruction;
                     (*s_etat_processus).test_instruction = 'N';                      (*s_etat_processus).test_instruction = 'N';
   
                       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, NULL);                      analyse(s_etat_processus, NULL);
   
                       if (registre_type_evaluation == 'E')
                       {
                           sf(s_etat_processus, 35);
                       }
                       else
                       {
                           cf(s_etat_processus, 35);
                       }
   
                     (*s_etat_processus).test_instruction = registre_test_2;                      (*s_etat_processus).test_instruction = registre_test_2;
   
                       if ((*s_etat_processus).erreur_systeme != d_es)
                       {
                           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).instruction_courante =
                                   instruction_courante;
                           return(d_erreur);
                       }
                       else if (((*s_etat_processus).erreur_execution != d_ex) ||
                               ((*s_etat_processus).exception != d_ep))
                       {
                           if ((*s_etat_processus).arret_si_exception == d_faux)
                           {
                               /*
                                * 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')
                           {
                               /*
                                * 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
                           {
                               // 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;
                               return(d_erreur);
                           }
                       }
   
                       if ((*s_etat_processus).erreur_systeme != d_es)
                       {
                           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).instruction_courante =
                                   instruction_courante;
                           return(d_erreur);
                       }
                       else if (((*s_etat_processus).erreur_execution != d_ex) ||
                               ((*s_etat_processus).exception != d_ep))
                       {
                           if ((*s_etat_processus).arret_si_exception == d_faux)
                           {
                               /*
                                * 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 séquenceur 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')
                           {
                               /*
                                * 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
                           {
                               // 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;
                               return(d_erreur);
                           }
                       }
                 }                  }
                 else if ((*s_etat_processus).constante_symbolique == 'N')                  else if ((*s_etat_processus).constante_symbolique == 'N')
                 {                  {
Line 3120  evaluation(struct_processus *s_etat_proc Line 4419  evaluation(struct_processus *s_etat_proc
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es;                          (*s_etat_processus).erreur_systeme = d_es;
                         presence_variable = d_faux;                          presence_variable = d_faux;
   
                           if ((*s_etat_processus).autorisation_nom_implicite
                                   == 'N')
                           {
                               if ((*((struct_nom *) (*s_objet_elementaire).objet))
                                       .symbole == d_faux)
                               {
                                   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 =
                                           d_ex_nom_implicite;
   
                                   if (type_evaluation == 'I')
                                   {
                                       (*s_etat_processus)
                                               .derniere_erreur_evaluation =
                                               (*s_etat_processus)
                                               .erreur_execution;
                                   }
                               }
                           }
                     }                      }
                     else                      else
                     {                      {
Line 3247  evaluation(struct_processus *s_etat_proc Line 4575  evaluation(struct_processus *s_etat_proc
   
                     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;                              // L'objet apparaît comme un symbole dans
                               // l'expression en cours d'évaluation. On se
                               // contente de l'empiler.
   
                         empilement_pile_systeme(s_etat_processus);                              if ((s_sous_objet = copie_objet(s_etat_processus,
                                       (*l_element_courant).donnee, 'P')) == NULL)
                               {
                                   (*s_etat_processus).instruction_courante =
                                           instruction_courante;
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                                  (*s_etat_processus).erreur_systeme =
                         {                                          d_es_allocation_memoire;
                             if (presence_variable_partagee == d_vrai)                                  return(d_erreur);
                               }
   
                               if (empilement(s_etat_processus,
                                       &((*s_etat_processus).l_base_pile),
                                       s_sous_objet) == d_erreur)
                             {                              {
                                 liberation(s_etat_processus,                                  (*s_etat_processus).instruction_courante =
                                         s_copie_variable_partagee);                                          instruction_courante;
                                   liberation(s_etat_processus, s_sous_objet);
                                   return(d_erreur);
                             }                              }
                           }
                           else
                           {
                               autorisation_empilement_programme =
                                       (*s_etat_processus)
                                       .autorisation_empilement_programme;
                               registre_position_courante = (*s_etat_processus)
                                       .position_courante;
   
                             if (presence_egalite == d_vrai)                              empilement_pile_systeme(s_etat_processus);
   
                               if ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  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);
                             }                              }
   
                             (*s_etat_processus).instruction_courante =                              (*(*s_etat_processus).l_base_pile_systeme)
                                     instruction_courante;                                      .retour_definition = 'Y';
                             return(d_erreur);                              (*(*s_etat_processus).l_base_pile_systeme)
                         }                                      .origine_routine_evaluation = 'Y';
   
                         (*(*s_etat_processus).l_base_pile_systeme)                              (*s_etat_processus).mode_execution_programme = 'Y';
                                 .retour_definition = 'Y';                              (*s_etat_processus)
                         (*(*s_etat_processus).l_base_pile_systeme)                                      .autorisation_empilement_programme = 'N';
                                 .origine_routine_evaluation = 'Y';  
   
                         (*s_etat_processus).mode_execution_programme = 'Y';                              (*(*s_etat_processus).l_base_pile_systeme)
                         (*s_etat_processus).autorisation_empilement_programme                                      .niveau_courant = (*s_etat_processus)
                                 = 'N';                                      .niveau_courant;
   
                         (*(*s_etat_processus).l_base_pile_systeme)                              if (presence_variable_partagee == d_faux)
                                 .niveau_courant = (*s_etat_processus)                              {
                                 .niveau_courant;                                  (*s_etat_processus).position_courante =
                                           (*((unsigned long *)
                                           ((*((*s_etat_processus)
                                           .s_liste_variables[(*s_etat_processus)
                                           .position_variable_courante]
                                           .objet)).objet)));
                               }
                               else
                               {
                                   (*s_etat_processus).position_courante =
                                           (*((unsigned long *)
                                           (*s_copie_variable_partagee).objet));
                                   liberation(s_etat_processus,
                                           s_copie_variable_partagee);
                               }
   
                         if (presence_variable_partagee == d_faux)                              if ((*s_etat_processus).profilage == d_vrai)
                         {                              {
                             (*s_etat_processus).position_courante =                                  profilage(s_etat_processus,
                                     (*((unsigned long *)                                          (*s_etat_processus).s_liste_variables
                                     ((*((*s_etat_processus).s_liste_variables                                          [(*s_etat_processus)
                                     [(*s_etat_processus)                                          .position_variable_courante].nom);
                                     .position_variable_courante]  
                                     .objet)).objet)));  
                         }  
                         else  
                         {  
                             (*s_etat_processus).position_courante =  
                                     (*((unsigned long *)  
                                     (*s_copie_variable_partagee).objet));  
                             liberation(s_etat_processus,  
                                     s_copie_variable_partagee);  
                         }  
   
                         if ((*s_etat_processus).profilage == d_vrai)                                  if ((*s_etat_processus).erreur_systeme != d_es)
                         {                                  {
                             profilage(s_etat_processus,                                      return(d_erreur);
                                     (*s_etat_processus).s_liste_variables                                  }
                                     [(*s_etat_processus)                              }
                                     .position_variable_courante].nom);  
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              registre_evaluation_forcee =
                                       (*s_etat_processus).evaluation_forcee;
   
                               if (type_evaluation == 'N')
                             {                              {
                                 return(d_erreur);                                  (*s_etat_processus).evaluation_forcee = 'Y';
                             }                              }
                         }  
   
                         if (sequenceur(s_etat_processus) == d_erreur)                              if (sequenceur(s_etat_processus) == d_erreur)
                         {  
                             if (presence_egalite == d_vrai)  
                             {                              {
                                 liberation(s_etat_processus, s_objet_evalue);                                  (*s_etat_processus).evaluation_forcee =
                                       registre_evaluation_forcee;
   
                                   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).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).instruction_courante =                              depilement_pile_systeme(s_etat_processus);
                                 instruction_courante;  
                         (*s_etat_processus).mode_execution_programme = 'N';  
   
                         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 3489  evaluation(struct_processus *s_etat_proc Line 4866  evaluation(struct_processus *s_etat_proc
   
                                     (*(*s_etat_processus).l_base_pile_systeme)                                      (*(*s_etat_processus).l_base_pile_systeme)
                                             .niveau_courant =                                              .niveau_courant =
                                               registre_niveau_courant;
                                     (*(*s_etat_processus).l_base_pile_systeme)                                      (*(*s_etat_processus).l_base_pile_systeme)
                                             .retour_definition =                                              .retour_definition =
                                             registre_retour_definition;                                              registre_retour_definition;
Line 3519  evaluation(struct_processus *s_etat_proc Line 4897  evaluation(struct_processus *s_etat_proc
   
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant =                                          .niveau_courant =
                                           registre_niveau_courant;
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .retour_definition =                                          .retour_definition =
                                         registre_retour_definition;                                          registre_retour_definition;
Line 3800  evaluation(struct_processus *s_etat_proc Line 5179  evaluation(struct_processus *s_etat_proc
                             ((*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))
                     {                      {
                           // Il est anormal de récupérer ici une erreur
                           // d'exécution puisqu'on empile une constante
                           // symbolique.
   
                         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 4089  evaluation(struct_processus *s_etat_proc Line 5472  evaluation(struct_processus *s_etat_proc
         (*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';
           cf(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 4106  evaluation(struct_processus *s_etat_proc Line 5500  evaluation(struct_processus *s_etat_proc
     }      }
     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.1  
changed lines
  Added in v.1.31

CVSweb interface <joel.bertrand@systella.fr>