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

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

version 1.73, 2013/03/06 09:00:26 version 1.120, 2025/04/15 10:17:50
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 48  evaluation(struct_processus *s_etat_proc Line 48  evaluation(struct_processus *s_etat_proc
 {  {
     integer8                        i;      integer8                        i;
     integer8                        j;      integer8                        j;
       integer8                        k;
       integer8                        l;
       integer8                        niveau_initial;
       integer8                        nombre_termes;
       integer8                        registre_hauteur_pile_operationnelle;
       integer8                        registre_position_courante;
   
   
     logical1                        drapeau_then;      logical1                        drapeau_then;
     logical1                        erreur_evaluation;      logical1                        erreur_evaluation;
Line 84  evaluation(struct_processus *s_etat_proc Line 91  evaluation(struct_processus *s_etat_proc
     unsigned char                   registre_evaluation_forcee;      unsigned char                   registre_evaluation_forcee;
     unsigned char                   registre_instruction_valide;      unsigned char                   registre_instruction_valide;
     unsigned char                   registre_mode_execution_programme;      unsigned char                   registre_mode_execution_programme;
     unsigned char                   registre_retour_definition;  
     unsigned char                   registre_test;      unsigned char                   registre_test;
     unsigned char                   registre_test_2;      unsigned char                   registre_test_2;
     unsigned char                   registre_type_evaluation;      unsigned char                   registre_type_evaluation;
   
     unsigned int                    registre_erreur_execution;      int                             registre_erreur_execution;
     unsigned int                    registre_erreur_systeme;      int                             registre_erreur_systeme;
     unsigned int                    registre_exception;      int                             registre_exception;
   
     unsigned long                   k;  
     unsigned long                   l;  
     unsigned long                   niveau_initial;  
     unsigned long                   nombre_termes;  
     unsigned long                   registre_hauteur_pile_operationnelle;  
     unsigned long                   registre_position_courante;  
   
     void                            (*fonction)();      void                            (*fonction)();
   
Line 291  evaluation(struct_processus *s_etat_proc Line 290  evaluation(struct_processus *s_etat_proc
                 if (presence_variable_partagee == d_faux)                  if (presence_variable_partagee == d_faux)
                 {                  {
                     (*s_etat_processus).position_courante =                      (*s_etat_processus).position_courante =
                             (*((unsigned long *) ((*(*(*s_etat_processus)                              (*((integer8 *) ((*(*(*s_etat_processus)
                             .pointeur_variable_courante).objet).objet)));                              .pointeur_variable_courante).objet).objet)));
                 }                  }
                 else                  else
                 {                  {
                     (*s_etat_processus).position_courante =                      (*s_etat_processus).position_courante =
                             (*((unsigned long *) (*s_copie_variable_partagee)                              (*((integer8 *) (*s_copie_variable_partagee)
                             .objet));                              .objet));
                     liberation(s_etat_processus, s_copie_variable_partagee);                      liberation(s_etat_processus, s_copie_variable_partagee);
                 }                  }
Line 324  evaluation(struct_processus *s_etat_proc Line 323  evaluation(struct_processus *s_etat_proc
   
                 if (sequenceur(s_etat_processus) == d_erreur)                  if (sequenceur(s_etat_processus) == d_erreur)
                 {                  {
                       depilement_pile_systeme(s_etat_processus);
   
                     (*s_etat_processus).evaluation_forcee =                      (*s_etat_processus).evaluation_forcee =
                             registre_evaluation_forcee;                              registre_evaluation_forcee;
                     (*s_etat_processus).mode_execution_programme =                      (*s_etat_processus).mode_execution_programme =
Line 409  evaluation(struct_processus *s_etat_proc Line 410  evaluation(struct_processus *s_etat_proc
                         .niveau_courant = (*s_etat_processus)                          .niveau_courant = (*s_etat_processus)
                         .niveau_courant;                          .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 422  evaluation(struct_processus *s_etat_proc Line 421  evaluation(struct_processus *s_etat_proc
                             profilage(s_etat_processus, NULL);                              profilage(s_etat_processus, NULL);
                         }                          }
   
                           depilement_pile_systeme(s_etat_processus);
   
                         (*s_etat_processus).evaluation_expression_compilee =                          (*s_etat_processus).evaluation_expression_compilee =
                                 registre_evaluation_expression_compilee;                                  registre_evaluation_expression_compilee;
   
Line 444  evaluation(struct_processus *s_etat_proc Line 445  evaluation(struct_processus *s_etat_proc
                             profilage(s_etat_processus, NULL);                              profilage(s_etat_processus, NULL);
                         }                          }
   
                           depilement_pile_systeme(s_etat_processus);
   
                         (*s_etat_processus).evaluation_expression_compilee =                          (*s_etat_processus).evaluation_expression_compilee =
                                 registre_evaluation_expression_compilee;                                  registre_evaluation_expression_compilee;
   
Line 463  evaluation(struct_processus *s_etat_proc Line 466  evaluation(struct_processus *s_etat_proc
                 }                  }
   
                 depilement_pile_systeme(s_etat_processus);                  depilement_pile_systeme(s_etat_processus);
                 depilement_pile_systeme(s_etat_processus);  
   
                 if ((*s_etat_processus).erreur_systeme != d_es)                  if ((*s_etat_processus).erreur_systeme != d_es)
                 {                  {
Line 711  evaluation(struct_processus *s_etat_proc Line 713  evaluation(struct_processus *s_etat_proc
          * Exécution de la séquence d'instructions           * Exécution de la séquence d'instructions
          */           */
   
         registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)  
                 .retour_definition;  
         (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';  
   
         l_element_courant = (struct_liste_chainee *) (*s_objet).objet;          l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
         autorisation_empilement_programme = (*s_etat_processus)          autorisation_empilement_programme = (*s_etat_processus)
                 .autorisation_empilement_programme;                  .autorisation_empilement_programme;
Line 760  evaluation(struct_processus *s_etat_proc Line 758  evaluation(struct_processus *s_etat_proc
                                 (*s_etat_processus)                                  (*s_etat_processus)
                                 .evaluation_expression_compilee;                                  .evaluation_expression_compilee;
   
                         if (((*(*s_etat_processus).pointeur_variable_courante)                          (*s_etat_processus).evaluation_expression_compilee
                                 .origine == 'E') && ((*(*s_etat_processus)                                  = 'Y';
                                 .pointeur_variable_courante).niveau == 0))  
                         {  
                             (*s_etat_processus).evaluation_expression_compilee  
                                     = 'Y';  
                         }  
                         else  
                         {  
                             (*s_etat_processus).evaluation_expression_compilee  
                                     = 'N';  
                         }  
   
                         analyse(s_etat_processus, (*((struct_fonction *)                          analyse(s_etat_processus, (*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
Line 798  evaluation(struct_processus *s_etat_proc Line 786  evaluation(struct_processus *s_etat_proc
                                 == 0)                                  == 0)
                         {                          {
                             envoi_signal_processus((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, rpl_sigalrm);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 814  evaluation(struct_processus *s_etat_proc Line 803  evaluation(struct_processus *s_etat_proc
                     {                      {
                         if ((*s_etat_processus).arret_si_exception == d_faux)                          if ((*s_etat_processus).arret_si_exception == d_faux)
                         {                          {
 uprintf("<IFERR 1>\n");  
                             /*                              /*
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
Line 1250  uprintf("<IFERR 1>\n"); Line 1238  uprintf("<IFERR 1>\n");
                             /*                              /*
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
 uprintf("<IFERR 2>\n");  
   
                             while(l_element_courant != NULL)                              while(l_element_courant != NULL)
                             {                              {
Line 1994  uprintf("<IFERR 2>\n"); Line 1981  uprintf("<IFERR 2>\n");
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 envoi_signal_processus((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, rpl_sigalrm);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 3096  uprintf("<IFERR 2>\n"); Line 3084  uprintf("<IFERR 2>\n");
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                           // Si l'objet élémentaire est un nom et que ce nom n'est
                           // pas un nom symbolique, il convient de l'évaluer.
   
                           if ((*s_objet_elementaire).type == NOM)
                           {
                               if (((*((struct_nom *) (*s_objet_elementaire)
                                       .objet)).symbole == d_faux) ||
                                       (type_evaluation == 'N'))
                               {
                                   if (evaluation(s_etat_processus,
                                           s_objet_elementaire, 'E') == d_erreur)
                                   {
                                       if (presence_variable_partagee == d_vrai)
                                       {
                                           (*(*s_etat_processus)
                                                   .pointeur_variable_courante)
                                                   .objet = NULL;
   
                                           if (pthread_mutex_unlock(
                                               &((*(*s_etat_processus)
                                               .pointeur_variable_partagee_courante
                                               ).mutex)) != 0)
                                           {
                                               (*s_etat_processus).erreur_systeme =
                                                       d_es_processus;
                                           }
                                       }
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   liberation(s_etat_processus,
                                           s_objet_elementaire);
   
   
                                   if (depilement(s_etat_processus,
                                           &((*s_etat_processus).l_base_pile),
                                           &s_objet_elementaire) == d_erreur)
                                   {
                                       if (presence_variable_partagee == d_vrai)
                                       {
                                           (*(*s_etat_processus)
                                                   .pointeur_variable_courante)
                                                   .objet = NULL;
   
                                           if (pthread_mutex_unlock(
                                               &((*(*s_etat_processus)
                                               .pointeur_variable_partagee_courante
                                               ).mutex)) != 0)
                                           {
                                               (*s_etat_processus).erreur_systeme =
                                                       d_es_processus;
                                           }
                                       }
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                     }                      }
   
                     /*                      /*
Line 3253  uprintf("<IFERR 2>\n"); Line 3321  uprintf("<IFERR 2>\n");
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                           // Si l'objet élémentaire est un nom et que ce nom n'est
                           // pas un nom symbolique, il convient de l'évaluer.
   
                           if ((*s_objet_elementaire).type == NOM)
                           {
                               if (((*((struct_nom *) (*s_objet_elementaire)
                                       .objet)).symbole == d_faux) ||
                                       (type_evaluation == 'N'))
                               {
                                   if (evaluation(s_etat_processus,
                                           s_objet_elementaire, 'E') == d_erreur)
                                   {
                                       if (presence_variable_partagee == d_vrai)
                                       {
                                           (*(*s_etat_processus)
                                                   .pointeur_variable_courante)
                                                   .objet = NULL;
   
                                           if (pthread_mutex_unlock(
                                               &((*(*s_etat_processus)
                                               .pointeur_variable_partagee_courante
                                               ).mutex)) != 0)
                                           {
                                               (*s_etat_processus).erreur_systeme =
                                                       d_es_processus;
                                           }
                                       }
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   liberation(s_etat_processus,
                                           s_objet_elementaire);
   
   
                                   if (depilement(s_etat_processus,
                                           &((*s_etat_processus).l_base_pile),
                                           &s_objet_elementaire) == d_erreur)
                                   {
                                       if (presence_variable_partagee == d_vrai)
                                       {
                                           (*(*s_etat_processus)
                                                   .pointeur_variable_courante)
                                                   .objet = NULL;
   
                                           if (pthread_mutex_unlock(
                                               &((*(*s_etat_processus)
                                               .pointeur_variable_partagee_courante
                                               ).mutex)) != 0)
                                           {
                                               (*s_etat_processus).erreur_systeme =
                                                       d_es_processus;
                                           }
                                       }
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                     }                      }
                     else if (((*((*(*s_etat_processus)                      else if (((*((*(*s_etat_processus)
                             .pointeur_variable_courante).objet)).type == ALG) ||                              .pointeur_variable_courante).objet)).type == ALG) ||
Line 3383  uprintf("<IFERR 2>\n"); Line 3531  uprintf("<IFERR 2>\n");
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
                             }                              }
   
                               depilement_pile_systeme(s_etat_processus);
   
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             return(d_erreur);                              return(d_erreur);
Line 3402  uprintf("<IFERR 2>\n"); Line 3552  uprintf("<IFERR 2>\n");
                                 .niveau_courant;                                  .niveau_courant;
   
                         (*s_etat_processus).position_courante =                          (*s_etat_processus).position_courante =
                                 (*((unsigned long *)                                  (*((integer8 *) ((*(*(*s_etat_processus)
                                 ((*(*(*s_etat_processus)  
                                 .pointeur_variable_courante).objet).objet)));                                  .pointeur_variable_courante).objet).objet)));
   
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
Line 3467  uprintf("<IFERR 2>\n"); Line 3616  uprintf("<IFERR 2>\n");
                                 liberation(s_etat_processus, s_objet_evalue);                                  liberation(s_etat_processus, s_objet_evalue);
                             }                              }
   
                               depilement_pile_systeme(s_etat_processus);
   
                             (*s_etat_processus).instruction_courante =                              (*s_etat_processus).instruction_courante =
                                     instruction_courante;                                      instruction_courante;
                             (*s_etat_processus).mode_execution_programme =                              (*s_etat_processus).mode_execution_programme =
Line 3667  uprintf("<IFERR 2>\n"); Line 3818  uprintf("<IFERR 2>\n");
                                 .evaluation_expression_compilee;                                  .evaluation_expression_compilee;
   
                         (*s_etat_processus).evaluation_expression_compilee                          (*s_etat_processus).evaluation_expression_compilee
                                 = 'N';                                  = 'Y';
   
                         if (evaluation(s_etat_processus, (*l_element_courant)                          if (evaluation(s_etat_processus, (*l_element_courant)
                                 .donnee, type_evaluation) == d_erreur)                                  .donnee, type_evaluation) == d_erreur)
Line 3778  uprintf("<IFERR 2>\n"); Line 3929  uprintf("<IFERR 2>\n");
                                 == 0)                                  == 0)
                         {                          {
                             envoi_signal_processus((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, rpl_sigalrm);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 3798  uprintf("<IFERR 2>\n"); Line 3950  uprintf("<IFERR 2>\n");
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
   
 uprintf("<IFERR 3>\n");  
                             if ((message = messages(s_etat_processus)) == NULL)                              if ((message = messages(s_etat_processus)) == NULL)
                             {                              {
                                 if (presence_egalite == d_vrai)                                  if (presence_egalite == d_vrai)
Line 4210  uprintf("<IFERR 3>\n"); Line 4361  uprintf("<IFERR 3>\n");
   
                             do                              do
                             {                              {
                                   l_element_courant = (*l_element_courant)
                                           .suivant;
                                 l_registre_atome = l_element_courant;                                  l_registre_atome = l_element_courant;
   
                                 if (l_element_courant == NULL)                                  if (l_element_courant == NULL)
Line 4249  uprintf("<IFERR 3>\n"); Line 4402  uprintf("<IFERR 3>\n");
                                     drapeau_then = TEST(instruction_then)                                      drapeau_then = TEST(instruction_then)
                                             ? d_vrai : d_faux;                                              ? d_vrai : d_faux;
                                 }                                  }
   
                                 l_element_courant = (*l_element_courant)  
                                         .suivant;  
                             } while(drapeau_then == d_faux);                              } while(drapeau_then == d_faux);
   
                             (*s_etat_processus).expression_courante =                              (*s_etat_processus).expression_courante =
Line 4271  uprintf("<IFERR 3>\n"); Line 4421  uprintf("<IFERR 3>\n");
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
   
 uprintf("<IFERR 4>\n");  
                             while(l_element_courant != NULL)                              while(l_element_courant != NULL)
                             {                              {
                                 if ((*(*l_element_courant).donnee).type == FCT)                                  if ((*(*l_element_courant).donnee).type == FCT)
Line 5002  uprintf("<IFERR 4>\n"); Line 5151  uprintf("<IFERR 4>\n");
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 envoi_signal_processus((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, rpl_sigalrm);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 5030  uprintf("<IFERR 4>\n"); Line 5180  uprintf("<IFERR 4>\n");
                                 == 0)                                  == 0)
                         {                          {
                             envoi_signal_processus((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, rpl_sigalrm);                                      .pid_processus_pere, rpl_sigalrm,
                                       d_faux);
                         }                          }
                         else                          else
                         {                          {
Line 5050  uprintf("<IFERR 4>\n"); Line 5201  uprintf("<IFERR 4>\n");
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
   
 uprintf("<IFERR 5>\n");  
                             if ((message = messages(s_etat_processus)) == NULL)                              if ((message = messages(s_etat_processus)) == NULL)
                             {                              {
                                 if (presence_egalite == d_vrai)                                  if (presence_egalite == d_vrai)
Line 5066  uprintf("<IFERR 5>\n"); Line 5216  uprintf("<IFERR 5>\n");
   
                             free(message);                              free(message);
   
                               l_registre_atome = l_element_courant;
   
                             while((*(*s_etat_processus).l_base_pile_systeme)                              while((*(*s_etat_processus).l_base_pile_systeme)
                                     .clause != 'R')                                      .clause != 'R')
                             {                              {
Line 5462  uprintf("<IFERR 5>\n"); Line 5614  uprintf("<IFERR 5>\n");
   
                             do                              do
                             {                              {
                                   (*s_etat_processus).expression_courante =
                                           l_registre_atome;
                                 l_registre_atome = l_element_courant;                                  l_registre_atome = l_element_courant;
   
                                 if (l_element_courant == NULL)                                  if (l_element_courant == NULL)
Line 5506  uprintf("<IFERR 5>\n"); Line 5660  uprintf("<IFERR 5>\n");
                                         .suivant;                                          .suivant;
                             } while(drapeau_then == d_faux);                              } while(drapeau_then == d_faux);
   
                             (*s_etat_processus).expression_courante =  
                                     l_registre_atome;  
   
                             (*(*s_etat_processus).l_base_pile_systeme)                              (*(*s_etat_processus).l_base_pile_systeme)
                                     .clause = 'X';                                      .clause = 'X';
                             instruction_then(s_etat_processus);                              instruction_then(s_etat_processus);
Line 5523  uprintf("<IFERR 5>\n"); Line 5674  uprintf("<IFERR 5>\n");
                              * Reprise sur erreur                               * Reprise sur erreur
                              */                               */
   
 uprintf("<IFERR 6>\n");  
                             while(l_element_courant != NULL)                              while(l_element_courant != NULL)
                             {                              {
                                 if ((*(*l_element_courant).donnee).type == FCT)                                  if ((*(*l_element_courant).donnee).type == FCT)
Line 6253  uprintf("<IFERR 6>\n"); Line 6403  uprintf("<IFERR 6>\n");
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 envoi_signal_processus((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, rpl_sigalrm);                                          .pid_processus_pere, rpl_sigalrm,
                                           d_faux);
                             }                              }
                             else                              else
                             {                              {
Line 6493  uprintf("<IFERR 6>\n"); Line 6644  uprintf("<IFERR 6>\n");
                             if (presence_variable_partagee == d_faux)                              if (presence_variable_partagee == d_faux)
                             {                              {
                                 (*s_etat_processus).position_courante =                                  (*s_etat_processus).position_courante =
                                         (*((unsigned long *)                                          (*((integer8 *)
                                         ((*(*(*s_etat_processus)                                          ((*(*(*s_etat_processus)
                                         .pointeur_variable_courante)                                          .pointeur_variable_courante)
                                         .objet).objet)));                                          .objet).objet)));
Line 6501  uprintf("<IFERR 6>\n"); Line 6652  uprintf("<IFERR 6>\n");
                             else                              else
                             {                              {
                                 (*s_etat_processus).position_courante =                                  (*s_etat_processus).position_courante =
                                         (*((unsigned long *)                                          (*((integer8 *)
                                         (*s_copie_variable_partagee).objet));                                          (*s_copie_variable_partagee).objet));
                                 liberation(s_etat_processus,                                  liberation(s_etat_processus,
                                         s_copie_variable_partagee);                                          s_copie_variable_partagee);
Line 6538  uprintf("<IFERR 6>\n"); Line 6689  uprintf("<IFERR 6>\n");
                                             s_objet_evalue);                                              s_objet_evalue);
                                 }                                  }
   
                                   depilement_pile_systeme(s_etat_processus);
   
                                 (*s_etat_processus).instruction_courante =                                  (*s_etat_processus).instruction_courante =
                                         instruction_courante;                                          instruction_courante;
                                 (*s_etat_processus).mode_execution_programme =                                  (*s_etat_processus).mode_execution_programme =
Line 6724  uprintf("<IFERR 6>\n"); Line 6877  uprintf("<IFERR 6>\n");
                                 }                                  }
   
                                 depilement_pile_systeme(s_etat_processus);                                  depilement_pile_systeme(s_etat_processus);
   
                                   if ((((*s_etat_processus).erreur_execution !=
                                           d_ex) || ((*s_etat_processus)
                                           .erreur_systeme != d_es)) &&
                                           ((*s_etat_processus).arret_si_exception
                                           == d_faux))
                                   {
                                       // Reprise sur erreur.
   
   //==============================================================================
   //  Réindentation
   //==============================================================================
   
               drapeau_then = d_faux;
   
               while(drapeau_then == d_faux)
               {
                   l_registre_atome = l_element_courant;
                   l_element_courant = (*l_element_courant).suivant;
   
                   if (l_element_courant == NULL)
                   {
                       /*
                        * La fin de l'expression est atteinte,
                        * le sequenceur reprend la main.
                        */
   
                       if (presence_egalite == d_vrai)
                       {
                           liberation(s_etat_processus, s_objet_evalue);
                       }
   
                       (*s_etat_processus).mode_execution_programme =
                               registre_mode_execution_programme;
                       return(d_absence_erreur);
                   }
   
                   if ((*(*l_element_courant).donnee).type == FCT)
                   {
                       (*s_etat_processus).instruction_courante =
                               (*((struct_fonction *)
                               (*(*l_element_courant).donnee)
                               .objet)).nom_fonction;
   
                       if (recherche_variable(s_etat_processus,
                               (*s_etat_processus).instruction_courante) == d_faux)
                       {
                           (*s_etat_processus).erreur_systeme = d_es;
                           fonction = (*((struct_fonction *)
                                   (*(*l_element_courant).donnee)
                                   .objet)).fonction;
   
                           /*
                            * Traitement de la pile système par les
                            * différentes instructions.
                            */
   
                           if (TEST(instruction_if) ||
                                   TEST(instruction_iferr) ||
                                   TEST(instruction_do) ||
                                   TEST(instruction_while) ||
                                   TEST(instruction_for) ||
                                   TEST(instruction_forall) ||
                                   TEST(instruction_start) ||
                                   TEST(instruction_select) ||
                                   TEST(instruction_case) ||
                                   TEST(instruction_critical) ||
                                   TEST(vers_niveau_superieur))
                           {
                               if (TEST(vers_niveau_superieur))
                               {
                                   registre_exception = (*s_etat_processus)
                                       .exception;
                                   registre_erreur_execution = (*s_etat_processus)
                                       .erreur_execution;
   
                                   analyse(s_etat_processus,
                                           vers_niveau_superieur);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   (*s_etat_processus).exception
                                           = registre_exception;
                                   (*s_etat_processus).erreur_execution =
                                       registre_erreur_execution;
                               }
                               else if (TEST(instruction_for) ||
                                       TEST(instruction_forall) ||
                                       TEST(instruction_start))
                               {
                                   empilement_pile_systeme(s_etat_processus);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   (*(*s_etat_processus).l_base_pile_systeme)
                                           .type_cloture = 'L';
                               }
                               else
                               {
                                   empilement_pile_systeme(s_etat_processus);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                           else if (TEST(instruction_end) ||
                                   TEST(instruction_next) ||
                                   TEST(instruction_step) ||
                                   TEST(vers_niveau_inferieur))
                           {
                               if (TEST(vers_niveau_inferieur))
                               {
                                   registre_exception = (*s_etat_processus)
                                           .exception;
                                   registre_erreur_execution = (*s_etat_processus)
                                           .erreur_execution;
   
                                   analyse(s_etat_processus,
                                           vers_niveau_inferieur);
   
                                   if ((*s_etat_processus).erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                               s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   (*s_etat_processus).exception
                                           = registre_exception;
                                   (*s_etat_processus).erreur_execution =
                                           registre_erreur_execution;
                               }
                               else if ((TEST(instruction_next) ||
                                       TEST(instruction_step)) &&
                                       ((*(*s_etat_processus)
                                       .l_base_pile_systeme)
                                       .type_cloture != 'L'))
                               {
                                   /*
                                    * Libération des compteurs
                                    * de boucle
                                    */
   
                                   presence_compteur = (((*(*s_etat_processus)
                                       .l_base_pile_systeme).type_cloture == 'F')
                                       || ((*(*s_etat_processus)
                                       .l_base_pile_systeme).type_cloture == 'A'))
                                       ? d_vrai : d_faux;
   
                                   if (((*(*s_etat_processus).l_base_pile_systeme)
                                       .type_cloture != 'S') && (presence_compteur
                                       == d_faux))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_erreur_traitement_boucle;
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                               s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   if (presence_compteur == d_vrai)
                                   {
                                       if (recherche_variable(s_etat_processus,
                                               (*(*s_etat_processus)
                                               .l_base_pile_systeme).nom_variable)
                                               == d_faux)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es;
                                           (*s_etat_processus).erreur_execution =
                                                   d_ex_erreur_traitement_boucle;
   
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante
                                                   = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       if ((*(*s_etat_processus)
                                               .pointeur_variable_courante)
                                               .objet == NULL)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es;
                                           (*s_etat_processus).erreur_execution =
                                                   d_ex_variable_partagee;
   
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante
                                                   = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       (*s_etat_processus)
                                               .niveau_courant--;
   
                                       if (retrait_variables_par_niveau(
                                               s_etat_processus) == d_erreur)
                                       {
                                           if (presence_egalite == d_vrai)
                                           {
                                               liberation(s_etat_processus,
                                                       s_objet_evalue);
                                           }
   
                                           (*s_etat_processus).instruction_courante                                                = instruction_courante;
                                           return(d_erreur);
                                       }
                                   }
   
                                   depilement_pile_systeme(s_etat_processus);
                               }
                               else
                               {
                                   // Traitement spécifique pour
                                   // la fin d'une section
                                   // critique
   
                                   if ((*s_etat_processus).l_base_pile_systeme
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_end_incoherent;
   
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
   
                                   if ((*(*s_etat_processus).l_base_pile_systeme)
                                           .type_cloture == 'Q')
                                   {
                                       if (pthread_mutex_unlock(
                                               &mutex_sections_critiques) != 0)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_processus;
   
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
   
                                           (*s_etat_processus).instruction_courante                                                = instruction_courante;
                                           return(d_erreur);
                                       }
   
                                       (*s_etat_processus).sections_critiques--;
                                   }
   
                                   depilement_pile_systeme(s_etat_processus);
   
                                   if ((*s_etat_processus)
                                           .erreur_systeme != d_es)
                                   {
                                       if (presence_egalite == d_vrai)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_evalue);
                                       }
   
                                       (*s_etat_processus).instruction_courante =
                                               instruction_courante;
                                       return(d_erreur);
                                   }
                               }
                           }
                           else if (TEST(instruction_then))
                           {
                               if ((*(*s_etat_processus).l_base_pile_systeme)
                                       .clause == 'R')
                               {
                                   (*(*s_etat_processus).l_base_pile_systeme)
                                           .clause = 'X';
                                   instruction_then(s_etat_processus);
                                   drapeau_then = d_vrai;
                               }
                           }
                       }
                   }
               }
   
               (*s_etat_processus).expression_courante =
                       l_element_courant;
               (*s_etat_processus).instruction_courante =
                       instruction_courante;
   
               (*s_etat_processus).exception = d_ep;
               (*s_etat_processus).erreur_execution = d_ex;
   
   //==============================================================================
   //  Fin de la réindentation
   //==============================================================================
                                   }
                             }                              }
                             else                              else
                             {                              {
Line 6746  uprintf("<IFERR 6>\n"); Line 7252  uprintf("<IFERR 6>\n");
                                 (*(*s_etat_processus).l_base_pile_systeme)                                  (*(*s_etat_processus).l_base_pile_systeme)
                                         .niveau_courant = (*s_etat_processus)                                          .niveau_courant = (*s_etat_processus)
                                         .niveau_courant;                                          .niveau_courant;
                                 empilement_pile_systeme(s_etat_processus);  
   
                                 if (evaluation(s_etat_processus,                                  if (evaluation(s_etat_processus,
                                         s_copie_variable_partagee,                                          s_copie_variable_partagee,
                                         type_evaluation) == d_erreur)                                          type_evaluation) == d_erreur)
                                 {                                  {
                                     depilement_pile_systeme(s_etat_processus);                                      depilement_pile_systeme(s_etat_processus);
                                     depilement_pile_systeme(s_etat_processus);  
   
                                     liberation(s_etat_processus,                                      liberation(s_etat_processus,
                                             s_copie_variable_partagee);                                              s_copie_variable_partagee);
Line 6781  uprintf("<IFERR 6>\n"); Line 7285  uprintf("<IFERR 6>\n");
                                 }                                  }
   
                                 depilement_pile_systeme(s_etat_processus);                                  depilement_pile_systeme(s_etat_processus);
                                 depilement_pile_systeme(s_etat_processus);  
   
                                 liberation(s_etat_processus,                                  liberation(s_etat_processus,
                                         s_copie_variable_partagee);                                          s_copie_variable_partagee);
Line 7167  uprintf("<IFERR 6>\n"); Line 7670  uprintf("<IFERR 6>\n");
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         autorisation_empilement_programme;                          autorisation_empilement_programme;
                 (*s_etat_processus).instruction_courante = instruction_courante;                  (*s_etat_processus).instruction_courante = instruction_courante;
                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =  
                         registre_retour_definition;  
   
                 return(d_erreur);                  return(d_erreur);
             }              }
   
Line 7182  uprintf("<IFERR 6>\n"); Line 7682  uprintf("<IFERR 6>\n");
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         autorisation_empilement_programme;                          autorisation_empilement_programme;
                 (*s_etat_processus).instruction_courante = instruction_courante;                  (*s_etat_processus).instruction_courante = instruction_courante;
                 (*(*s_etat_processus).l_base_pile_systeme).retour_definition =  
                         registre_retour_definition;  
   
                 return(d_erreur);                  return(d_erreur);
             }              }
         }          }
Line 7192  uprintf("<IFERR 6>\n"); Line 7689  uprintf("<IFERR 6>\n");
         (*s_etat_processus).autorisation_empilement_programme =          (*s_etat_processus).autorisation_empilement_programme =
                 autorisation_empilement_programme;                  autorisation_empilement_programme;
         (*s_etat_processus).instruction_courante = instruction_courante;          (*s_etat_processus).instruction_courante = instruction_courante;
         (*(*s_etat_processus).l_base_pile_systeme).retour_definition =  
                 registre_retour_definition;  
     }      }
     else if ((*s_objet).type == FCT)      else if ((*s_objet).type == FCT)
     {      {
Line 7202  uprintf("<IFERR 6>\n"); Line 7697  uprintf("<IFERR 6>\n");
   
         registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)          registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
                 ? 'E' : 'N';                  ? 'E' : 'N';
         cf(s_etat_processus, 35);  
           if (type_evaluation == 'N')
           {
               cf(s_etat_processus, 35);
           }
           else
           {
               sf(s_etat_processus, 35);
           }
   
         analyse(s_etat_processus, (*((struct_fonction *)          analyse(s_etat_processus, (*((struct_fonction *)
                 (*s_objet).objet)).fonction);                  (*s_objet).objet)).fonction);
Removed from v.1.73  
changed lines
  Added in v.1.120

CVSweb interface <joel.bertrand@systella.fr>