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

Diff for /rpl/src/instructions_p7.c between versions 1.21.2.3 and 1.84

version 1.21.2.3, 2011/05/09 13:52:19 version 1.84, 2020/01/10 11:15:47
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.24    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2020 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 94  instruction_protect(struct_processus *s_ Line 94  instruction_protect(struct_processus *s_
             return;              return;
         }          }
   
         ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          (*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante]).variable_verrouillee = d_vrai;                  .variable_verrouillee = d_vrai;
     }      }
     else if ((*s_objet).type == LST)      else if ((*s_objet).type == LST)
     {      {
Line 122  instruction_protect(struct_processus *s_ Line 122  instruction_protect(struct_processus *s_
                 return;                  return;
             }              }
   
             ((*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante)
                     .position_variable_courante]).variable_verrouillee = d_vrai;                      .variable_verrouillee = d_vrai;
   
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
Line 157  instruction_protect(struct_processus *s_ Line 157  instruction_protect(struct_processus *s_
 void  void
 instruction_parameter(struct_processus *s_etat_processus)  instruction_parameter(struct_processus *s_etat_processus)
 {  {
     logical1                            presence_variable;  
   
     long                                i;  
   
     struct_liste_chainee                *l_element_courant;      struct_liste_chainee                *l_element_courant;
   
     struct_objet                        *s_objet;      struct_objet                        *s_objet;
Line 207  instruction_parameter(struct_processus * Line 203  instruction_parameter(struct_processus *
   
     if ((*s_objet).type == NOM)      if ((*s_objet).type == NOM)
     {      {
         if (recherche_variable(s_etat_processus, ((*((struct_nom *)          if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
                 (*s_objet).objet)).nom)) == d_faux)                  (*s_objet).objet)).nom)) == d_faux)
         {          {
             liberation(s_etat_processus, s_objet);              liberation(s_etat_processus, s_objet);
Line 217  instruction_parameter(struct_processus * Line 213  instruction_parameter(struct_processus *
             return;              return;
         }          }
   
         i = (*s_etat_processus).position_variable_courante;          (*(*s_etat_processus).pointeur_variable_courante)
         presence_variable = d_faux;                  .variable_verrouillee = d_vrai;
   
         while(i >= 0)  
         {  
             if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,  
                     (*((struct_nom *) (*s_objet).objet)).nom) == 0)  
                     && ((*s_etat_processus).s_liste_variables[i].niveau == 1))  
             {  
                 presence_variable = d_vrai;  
                 break;  
             }  
   
             i--;  
         }  
   
         (*s_etat_processus).position_variable_courante = i;  
   
         if (presence_variable == d_faux)  
         {  
             liberation(s_etat_processus, s_objet);  
   
             (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;  
             return;  
         }  
   
         ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                 .position_variable_courante]).variable_verrouillee = d_vrai;  
     }      }
     else if ((*s_objet).type == LST)      else if ((*s_objet).type == LST)
     {      {
Line 260  instruction_parameter(struct_processus * Line 230  instruction_parameter(struct_processus *
                 return;                  return;
             }              }
   
             if (recherche_variable(s_etat_processus, (*((struct_nom *)              if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
                     (*(*l_element_courant).donnee).objet)).nom) == d_faux)                      (*(*l_element_courant).donnee).objet)).nom) == d_faux)
             {              {
                 liberation(s_etat_processus, s_objet);                  liberation(s_etat_processus, s_objet);
Line 271  instruction_parameter(struct_processus * Line 241  instruction_parameter(struct_processus *
                 return;                  return;
             }              }
   
             i = (*s_etat_processus).position_variable_courante;              (*(*s_etat_processus).pointeur_variable_courante)
             presence_variable = d_faux;                      .variable_verrouillee = d_vrai;
   
             while(i >= 0)  
             {  
                 if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,  
                         (*((struct_nom *) (*(*l_element_courant).donnee)  
                         .objet)).nom) == 0) && ((*s_etat_processus)  
                         .s_liste_variables[i].niveau == 1))  
                 {  
                     presence_variable = d_vrai;  
                     break;  
                 }  
   
                 i--;  
             }  
   
             (*s_etat_processus).position_variable_courante = i;  
   
             if (presence_variable == d_faux)  
             {  
                 liberation(s_etat_processus, s_objet);  
   
                 (*s_etat_processus).erreur_execution =  
                         d_ex_variable_non_definie;  
                 return;  
             }  
   
             ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante]).variable_verrouillee = d_vrai;  
   
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
Line 776  instruction_poke(struct_processus *s_eta Line 718  instruction_poke(struct_processus *s_eta
             return;              return;
         }          }
   
         if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 807  instruction_poke(struct_processus *s_eta Line 750  instruction_poke(struct_processus *s_eta
                     // figure !                      // figure !
   
                     action.sa_handler = SIG_IGN;                      action.sa_handler = SIG_IGN;
                     action.sa_flags = SA_ONSTACK;                      action.sa_flags = 0;
   
   #                   ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                       if (pthread_mutex_lock(&mutex_sigaction) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                     if (sigaction(SIGPIPE, &action, &registre) != 0)                      if (sigaction(SIGPIPE, &action, &registre) != 0)
                     {                      {
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));                          pthread_mutex_unlock(&mutex_sigaction);
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         return;                          return;
Line 821  instruction_poke(struct_processus *s_eta Line 783  instruction_poke(struct_processus *s_eta
                     // débloquer les instructions de type WF* pour les                      // débloquer les instructions de type WF* pour les
                     // lectures bloquantes.                      // lectures bloquantes.
   
                     if (kill((*(*((struct_processus_fils *)                      if (envoi_signal_processus((*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet))                              (*(*l_element_courant).donnee).objet))
                             .thread).pid, SIGINJECT) != 0)                              .thread).pid, rpl_siginject, d_faux) != 0)
                     {                      {
                         // Le processus fils peut s'être terminé.                          // Le processus fils peut s'être terminé.
                         break;                          break;
Line 841  instruction_poke(struct_processus *s_eta Line 803  instruction_poke(struct_processus *s_eta
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                          if ((*s_etat_processus).erreur_systeme != d_es)
                         {                          {
                             pthread_mutex_unlock(&((*s_etat_processus).mutex));                              pthread_mutex_unlock(&mutex_sigaction);
                               pthread_mutex_unlock(&((*s_etat_processus)
                                       .mutex_pile_processus));
                             return;                              return;
                         }                          }
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   else  
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   endif  
   
                     while((longueur_ecriture = write_atomic(s_etat_processus,                      while((longueur_ecriture = write_atomic(s_etat_processus,
                             (*(*((struct_processus_fils *)                              (*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet)).thread)                              (*(*l_element_courant).donnee).objet)).thread)
                             .pipe_nombre_injections[1], "-",                              .pipe_nombre_injections[1], "-",
                             sizeof(unsigned char))) != sizeof(unsigned char))                              sizeof(unsigned char))) != sizeof(unsigned char))
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES  
                         while(sem_wait(&((*s_etat_processus)  
                                 .semaphore_fork)) == -1)  
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {  
                             if (errno != EINTR)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }  
   
                         if (longueur_ecriture == -1)                          if (longueur_ecriture == -1)
                         {                          {
                             pthread_mutex_unlock(&((*s_etat_processus).mutex));                              pthread_mutex_unlock(&mutex_sigaction);
                               pthread_mutex_unlock(&((*s_etat_processus)
                                       .mutex_pile_processus));
   
                             liberation(s_etat_processus, s_objet_argument_1);                              liberation(s_etat_processus, s_objet_argument_1);
                             liberation(s_etat_processus, s_objet_argument_2);                              liberation(s_etat_processus, s_objet_argument_2);
Line 911  instruction_poke(struct_processus *s_eta Line 847  instruction_poke(struct_processus *s_eta
   
                             if (sigaction(SIGPIPE, &registre, NULL) != 0)                              if (sigaction(SIGPIPE, &registre, NULL) != 0)
                             {                              {
                                   pthread_mutex_unlock(&mutex_sigaction);
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_signal;                                          d_es_signal;
                                 return;                                  return;
Line 918  instruction_poke(struct_processus *s_eta Line 855  instruction_poke(struct_processus *s_eta
   
                             return;                              return;
                         }                          }
   
 #                       ifndef SEMAPHORES_NOMMES  
                         if (sem_post(&((*s_etat_processus)  
                                 .semaphore_fork)) != 0)  
 #                       else  
                         if (sem_post((*s_etat_processus)  
                                 .semaphore_fork) != 0)  
 #                       endif  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
   
                     if (ecriture_pipe(s_etat_processus,                      if (ecriture_pipe(s_etat_processus,
Line 946  instruction_poke(struct_processus *s_eta Line 871  instruction_poke(struct_processus *s_eta
                         }                          }
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {  
                         if (errno == EINTR)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }  
   
                     if (registre_stop == 0)                      if (registre_stop == 0)
                     {                      {
                         if ((*s_etat_processus)                          if ((*s_etat_processus)
Line 979  instruction_poke(struct_processus *s_eta Line 891  instruction_poke(struct_processus *s_eta
   
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));                          pthread_mutex_unlock(&mutex_sigaction);
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         return;                          return;
                     }                      }
   
                       if (pthread_mutex_unlock(&mutex_sigaction) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           if (errno != EINTR)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
                       }
   
                     break;                      break;
                 }                  }
             }              }
Line 1011  instruction_poke(struct_processus *s_eta Line 945  instruction_poke(struct_processus *s_eta
                     // de lecteur et on peut se prendre un SIGPIPE dans la                      // de lecteur et on peut se prendre un SIGPIPE dans la
                     // figure !                      // figure !
   
   #                   ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                       if (pthread_mutex_lock(&mutex_sigaction) != 0)
                       {
   #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                     action.sa_handler = SIG_IGN;                      action.sa_handler = SIG_IGN;
                     action.sa_flags = SA_ONSTACK;                      action.sa_flags = 0;
   
                     if (sigaction(SIGPIPE, &action, &registre) != 0)                      if (sigaction(SIGPIPE, &action, &registre) != 0)
                     {                      {
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));  #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           pthread_mutex_unlock(&mutex_sigaction);
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         return;                          return;
Line 1030  instruction_poke(struct_processus *s_eta Line 1015  instruction_poke(struct_processus *s_eta
                             (*(*l_element_courant).donnee).objet)).thread)                              (*(*l_element_courant).donnee).objet)).thread)
                             .mutex)) != 0)                              .mutex)) != 0)
                     {                      {
   #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           pthread_mutex_unlock(&mutex_sigaction);
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
Line 1038  instruction_poke(struct_processus *s_eta Line 1040  instruction_poke(struct_processus *s_eta
                             (*(*l_element_courant).donnee).objet)).thread)                              (*(*l_element_courant).donnee).objet)).thread)
                             .thread_actif == d_vrai)                              .thread_actif == d_vrai)
                     {                      {
                         if (pthread_kill((*(*((struct_processus_fils *)                          if (envoi_signal_thread(NULL,
                                   (*(*((struct_processus_fils *)
                                 (*(*l_element_courant).donnee).objet)).thread)                                  (*(*l_element_courant).donnee).objet)).thread)
                                 .tid, SIGINJECT) != 0)                                  .tid, rpl_siginject) != 0)
                         {                          {
                             // Le processus fils peut s'être terminé.                              // Le processus fils peut s'être terminé.
   
Line 1049  instruction_poke(struct_processus *s_eta Line 1052  instruction_poke(struct_processus *s_eta
                                     (*(*l_element_courant).donnee).objet))                                      (*(*l_element_courant).donnee).objet))
                                     .thread).mutex)) != 0)                                      .thread).mutex)) != 0)
                             {                              {
   #                               ifndef SEMAPHORES_NOMMES
                                       while(sem_wait(&((*s_etat_processus)
                                               .semaphore_fork)) != 0)
   #                               else
                                       while(sem_wait((*s_etat_processus)
                                               .semaphore_fork) != 0)
   #                               endif
                                   {
                                       if (errno != EINTR)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_processus;
                                           return;
                                       }
                                   }
   
                                   pthread_mutex_unlock(&mutex_sigaction);
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
                                 return;                                  return;
Line 1064  instruction_poke(struct_processus *s_eta Line 1084  instruction_poke(struct_processus *s_eta
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .thread).mutex)) != 0)                                  .thread).mutex)) != 0)
                         {                          {
   #                           ifndef SEMAPHORES_NOMMES
                                   while(sem_wait(&((*s_etat_processus)
                                           .semaphore_fork)) != 0)
   #                           else
                                   while(sem_wait((*s_etat_processus)
                                           .semaphore_fork) != 0)
   #                           endif
                               {
                                   if (errno != EINTR)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_processus;
                                       return;
                                   }
                               }
   
                               pthread_mutex_unlock(&mutex_sigaction);
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             return;                              return;
                         }                          }
Line 1075  instruction_poke(struct_processus *s_eta Line 1112  instruction_poke(struct_processus *s_eta
                             (*(*l_element_courant).donnee).objet)).thread)                              (*(*l_element_courant).donnee).objet)).thread)
                             .mutex)) != 0)                              .mutex)) != 0)
                     {                      {
   #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           pthread_mutex_unlock(&mutex_sigaction);
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
Line 1091  instruction_poke(struct_processus *s_eta Line 1145  instruction_poke(struct_processus *s_eta
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                          if ((*s_etat_processus).erreur_systeme != d_es)
                         {                          {
                             pthread_mutex_unlock(&((*s_etat_processus).mutex));  #                           ifndef SEMAPHORES_NOMMES
                                   while(sem_wait(&((*s_etat_processus)
                                           .semaphore_fork)) != 0)
   #                           else
                                   while(sem_wait((*s_etat_processus)
                                           .semaphore_fork) != 0)
   #                           endif
                               {
                                   if (errno != EINTR)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_processus;
                                       return;
                                   }
                               }
   
                               pthread_mutex_unlock(&mutex_sigaction);
                               pthread_mutex_unlock(&((*s_etat_processus)
                                       .mutex_pile_processus));
                             return;                              return;
                         }                          }
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
 #                   else  
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
 #                   endif  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
   
                     while((longueur_ecriture = write_atomic(s_etat_processus,                      while((longueur_ecriture = write_atomic(s_etat_processus,
                             (*(*((struct_processus_fils *)                              (*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet)).thread)                              (*(*l_element_courant).donnee).objet)).thread)
                             .pipe_nombre_injections[1], "-",                              .pipe_nombre_injections[1], "-",
                             sizeof(unsigned char))) != sizeof(unsigned char))                              sizeof(unsigned char))) != sizeof(unsigned char))
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES  
                         while(sem_wait(&((*s_etat_processus)  
                                 .semaphore_fork)) == -1)  
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {  
                             if (errno != EINTR)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }  
   
                         if (longueur_ecriture == -1)                          if (longueur_ecriture == -1)
                         {                          {
                             pthread_mutex_unlock(&((*s_etat_processus).mutex));                              pthread_mutex_unlock(&((*s_etat_processus)
                                       .mutex_pile_processus));
   
                             liberation(s_etat_processus, s_objet_argument_1);                              liberation(s_etat_processus, s_objet_argument_1);
                             liberation(s_etat_processus, s_objet_argument_2);                              liberation(s_etat_processus, s_objet_argument_2);
Line 1157  instruction_poke(struct_processus *s_eta Line 1204  instruction_poke(struct_processus *s_eta
   
                             if (sigaction(SIGPIPE, &registre, NULL) != 0)                              if (sigaction(SIGPIPE, &registre, NULL) != 0)
                             {                              {
   #                               ifndef SEMAPHORES_NOMMES
                                       while(sem_wait(&((*s_etat_processus)
                                               .semaphore_fork)) != 0)
   #                               else
                                       while(sem_wait((*s_etat_processus)
                                               .semaphore_fork) != 0)
   #                               endif
                                   {
                                       if (errno != EINTR)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_processus;
                                           return;
                                       }
                                   }
   
                                   pthread_mutex_unlock(&mutex_sigaction);
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_signal;                                          d_es_signal;
                                 return;                                  return;
                             }                              }
   
                             return;  #                           ifndef SEMAPHORES_NOMMES
                         }                                  while(sem_wait(&((*s_etat_processus)
                                           .semaphore_fork)) != 0)
   #                           else
                                   while(sem_wait((*s_etat_processus)
                                           .semaphore_fork) != 0)
   #                           endif
                               {
                                   if (errno != EINTR)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_processus;
                                       return;
                                   }
                               }
   
 #                       ifndef SEMAPHORES_NOMMES                              pthread_mutex_unlock(&mutex_sigaction);
                         if (sem_post(&((*s_etat_processus)  
                                 .semaphore_fork)) != 0)  
 #                       else  
                         if (sem_post((*s_etat_processus)  
                                 .semaphore_fork) != 0)  
 #                       endif  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;                              return;
                         }                          }
                     }                      }
Line 1192  instruction_poke(struct_processus *s_eta Line 1261  instruction_poke(struct_processus *s_eta
                         }                          }
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  
                     while(sem_wait(&((*s_etat_processus)  
                             .semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus)  
                             .semaphore_fork) == -1)  
 #                   endif  
                     {  
                         if (errno != EINTR)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }  
   
                     if (registre_stop == 0)                      if (registre_stop == 0)
                     {                      {
                         if ((*s_etat_processus)                          if ((*s_etat_processus)
Line 1227  instruction_poke(struct_processus *s_eta Line 1281  instruction_poke(struct_processus *s_eta
   
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));  #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           pthread_mutex_unlock(&mutex_sigaction);
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         return;                          return;
                     }                      }
   
                       if (pthread_mutex_unlock(&mutex_sigaction) != 0)
                       {
   #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           if (errno != EINTR)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
                       }
   
                     break;                      break;
                 }                  }
             }              }
Line 1240  instruction_poke(struct_processus *s_eta Line 1348  instruction_poke(struct_processus *s_eta
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 1342  instruction_private(struct_processus *s_ Line 1451  instruction_private(struct_processus *s_
             return;              return;
         }          }
   
         if (pthread_mutex_lock(&((*(*s_etat_processus)  
                 .s_liste_variables_partagees).mutex)) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
   
         if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)          if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
                 (*s_objet).objet)).nom), ((*s_etat_processus).s_liste_variables                  (*s_objet).objet)).nom), (*(*s_etat_processus)
                 [(*s_etat_processus).position_variable_courante])                  .pointeur_variable_courante).variable_partagee,
                 .variable_partagee, ((*s_etat_processus).s_liste_variables                  (*(*s_etat_processus).pointeur_variable_courante).origine)
                 [(*s_etat_processus).position_variable_courante]).origine)                  == NULL)
                 == d_faux)  
         {          {
             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             liberation(s_etat_processus, s_objet);              liberation(s_etat_processus, s_objet);
   
             (*s_etat_processus).erreur_systeme = d_es;              (*s_etat_processus).erreur_systeme = d_es;
             return;              return;
         }          }
   
         (*s_etat_processus).s_liste_variables[(*s_etat_processus)          (*(*s_etat_processus).pointeur_variable_courante).objet =
                 .position_variable_courante].objet =                  (*(*s_etat_processus).pointeur_variable_partagee_courante)
                 (*(*s_etat_processus).s_liste_variables_partagees).table                  .objet;
                 [(*(*s_etat_processus).s_liste_variables_partagees)          (*(*s_etat_processus).pointeur_variable_partagee_courante).objet = NULL;
                 .position_variable].objet;  
         (*(*s_etat_processus).s_liste_variables_partagees).table  
                 [(*(*s_etat_processus).s_liste_variables_partagees)  
                 .position_variable].objet = NULL;  
   
         if (retrait_variable_partagee(s_etat_processus,          if (retrait_variable_partagee(s_etat_processus,
                 (*((struct_nom *) (*s_objet).objet)).nom,                  (*((struct_nom *) (*s_objet).objet)).nom,
                 (*s_etat_processus).s_liste_variables[(*s_etat_processus)                  (*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].variable_partagee) == d_erreur)                  .variable_partagee) == d_erreur)
         {          {
             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             liberation(s_etat_processus, s_objet);              liberation(s_etat_processus, s_objet);
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
                 .position_variable_courante].origine == 'P')  
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante)
                     .position_variable_courante].variable_partagee.adresse = 0;                      .variable_partagee.adresse = 0;
         }          }
         else          else
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante)
                     .position_variable_courante].variable_partagee.pointeur                      .variable_partagee.pointeur = NULL;
                     = NULL;  
         }  
   
         if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                 .s_liste_variables_partagees).mutex)) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }          }
     }      }
     else if ((*s_objet).type == LST)      else if ((*s_objet).type == LST)
Line 1439  instruction_private(struct_processus *s_ Line 1513  instruction_private(struct_processus *s_
                 return;                  return;
             }              }
   
             if (pthread_mutex_lock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)              if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
                     (*s_objet).objet)).nom), ((*s_etat_processus)                      (*s_objet).objet)).nom), (*(*s_etat_processus)
                     .s_liste_variables[(*s_etat_processus)                      .pointeur_variable_courante).variable_partagee,
                     .position_variable_courante]).variable_partagee,                      (*(*s_etat_processus).pointeur_variable_courante).origine)
                     ((*s_etat_processus).s_liste_variables                      == NULL)
                     [(*s_etat_processus).position_variable_courante]).origine)  
                     == d_faux)  
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex)) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 liberation(s_etat_processus, s_objet);                  liberation(s_etat_processus, s_objet);
   
                 (*s_etat_processus).erreur_systeme = d_es;                  (*s_etat_processus).erreur_systeme = d_es;
Line 1469  instruction_private(struct_processus *s_ Line 1527  instruction_private(struct_processus *s_
                 return;                  return;
             }              }
   
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante).objet =
                     .position_variable_courante].objet =                      (*(*s_etat_processus).pointeur_variable_partagee_courante)
                     (*(*s_etat_processus).s_liste_variables_partagees).table                      .objet;
                     [(*(*s_etat_processus).s_liste_variables_partagees)              (*(*s_etat_processus).pointeur_variable_partagee_courante).objet
                     .position_variable].objet;                      = NULL;
             (*(*s_etat_processus).s_liste_variables_partagees).table  
                     [(*(*s_etat_processus).s_liste_variables_partagees)  
                     .position_variable].objet = NULL;  
   
             if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)              if ((*(*s_etat_processus).pointeur_variable_courante).origine
                     .position_variable_courante].origine == 'P')                      == 'P')
             {              {
                 (*s_etat_processus).s_liste_variables[(*s_etat_processus)                  (*(*s_etat_processus).pointeur_variable_courante)
                         .position_variable_courante].variable_partagee.adresse                          .variable_partagee.adresse = 0;
                         = 0;  
             }              }
             else              else
             {              {
                 (*s_etat_processus).s_liste_variables[(*s_etat_processus)                  (*(*s_etat_processus).pointeur_variable_courante)
                         .position_variable_courante].variable_partagee.pointeur                          .variable_partagee.pointeur = NULL;
                         = NULL;  
             }              }
   
             if (retrait_variable_partagee(s_etat_processus,              if (retrait_variable_partagee(s_etat_processus,
                     (*((struct_nom *) (*s_objet).objet)).nom,                      (*((struct_nom *) (*s_objet).objet)).nom,
                     (*s_etat_processus).s_liste_variables[(*s_etat_processus)                      (*(*s_etat_processus).pointeur_variable_courante)
                     .position_variable_courante].variable_statique) == d_erreur)                      .variable_statique) == d_erreur)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex)) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 liberation(s_etat_processus, s_objet);                  liberation(s_etat_processus, s_objet);
                 return;                  return;
             }              }
   
             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
     }      }
Removed from v.1.21.2.3  
changed lines
  Added in v.1.84

CVSweb interface <joel.bertrand@systella.fr>