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

Diff for /rpl/src/instructions_s9.c between versions 1.9 and 1.93

version 1.9, 2010/04/21 13:45:49 version 1.93, 2025/04/15 10:17:56
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 57  instruction_sort(struct_processus *s_eta Line 57  instruction_sort(struct_processus *s_eta
     struct_objet                *s_objet_copie;      struct_objet                *s_objet_copie;
     struct_objet                *s_objet_critere;      struct_objet                *s_objet_critere;
     struct_objet                *s_objet_liste;      struct_objet                *s_objet_liste;
       struct_objet                *s_objet_registre;
     struct_objet                *s_objet_test;      struct_objet                *s_objet_test;
   
     signed long                 indice_i;      integer8                    ecartement;
     signed long                 indice_j;      integer8                    indice_i;
     signed long                 indice_k;      integer8                    indice_j;
     signed long                 indice_l;      integer8                    indice_k;
       integer8                    indice_l;
     unsigned long               ecartement;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 140  instruction_sort(struct_processus *s_eta Line 140  instruction_sort(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].variable_verrouillee == d_vrai)                  .variable_verrouillee == d_vrai)
         {          {
             (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
   
Line 151  instruction_sort(struct_processus *s_eta Line 151  instruction_sort(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
                 .position_variable_courante].objet == NULL)  
         {          {
             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,              if (recherche_variable_partagee(s_etat_processus,
                     (*s_etat_processus).s_liste_variables                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     [(*s_etat_processus).position_variable_courante].nom,                      (*(*s_etat_processus).pointeur_variable_courante)
                     (*s_etat_processus).s_liste_variables                      .variable_partagee, (*(*s_etat_processus)
                     [(*s_etat_processus).position_variable_courante]                      .pointeur_variable_courante).origine) == NULL)
                     .variable_partagee, (*s_etat_processus).s_liste_variables  
                     [(*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;  
                 }  
   
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_type_argument;                          d_ex_erreur_type_argument;
   
Line 186  instruction_sort(struct_processus *s_eta Line 168  instruction_sort(struct_processus *s_eta
                 return;                  return;
             }              }
   
             if (((*(*(*s_etat_processus).s_liste_variables_partagees)              if (((*(*(*s_etat_processus).pointeur_variable_partagee_courante)
                     .table[(*(*s_etat_processus).s_liste_variables_partagees)                      .objet).type != LST) && ((*(*(*s_etat_processus)
                     .position_variable].objet).type != LST) &&                      .pointeur_variable_partagee_courante).objet).type != TBL))
                     ((*(*(*s_etat_processus).s_liste_variables_partagees)  
                     .table[(*(*s_etat_processus).s_liste_variables_partagees)  
                     .position_variable].objet).type != TBL))  
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
Line 211  instruction_sort(struct_processus *s_eta Line 190  instruction_sort(struct_processus *s_eta
   
             liberation(s_etat_processus, s_objet_liste);              liberation(s_etat_processus, s_objet_liste);
   
             s_objet_liste = (*(*s_etat_processus).s_liste_variables_partagees)              s_objet_liste = (*(*s_etat_processus)
                     .table[(*(*s_etat_processus).s_liste_variables_partagees)                      .pointeur_variable_partagee_courante).objet;
                     .position_variable].objet;  
   
             if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,              if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
                     'N')) == NULL)                      'N')) == NULL)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
Line 233  instruction_sort(struct_processus *s_eta Line 211  instruction_sort(struct_processus *s_eta
         }          }
         else          else
         {          {
             if (((*(*s_etat_processus).s_liste_variables              if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
                     [(*s_etat_processus).position_variable_courante].objet)                      .type != LST) && ((*(*(*s_etat_processus)
                     .type != LST) &&                      .pointeur_variable_courante).objet).type != TBL))
                     ((*(*s_etat_processus).s_liste_variables  
                     [(*s_etat_processus).position_variable_courante].objet)  
                     .type != TBL))  
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_type_argument;                          d_ex_erreur_type_argument;
Line 251  instruction_sort(struct_processus *s_eta Line 226  instruction_sort(struct_processus *s_eta
   
             liberation(s_etat_processus, s_objet_liste);              liberation(s_etat_processus, s_objet_liste);
   
             s_objet_liste = (*s_etat_processus).s_liste_variables              s_objet_liste = (*(*s_etat_processus).pointeur_variable_courante)
                     [(*s_etat_processus).position_variable_courante].objet;                      .objet;
   
             if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,              if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
                     'N')) == NULL)                      'N')) == NULL)
Line 264  instruction_sort(struct_processus *s_eta Line 239  instruction_sort(struct_processus *s_eta
   
         liberation(s_etat_processus, s_objet_liste);          liberation(s_etat_processus, s_objet_liste);
         s_objet_liste = s_objet_copie;          s_objet_liste = s_objet_copie;
           (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_liste;
         (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                 .position_variable_courante].objet = s_objet_liste;  
   
         presence_nom = d_vrai;          presence_nom = d_vrai;
     }      }
     else      else
Line 463  instruction_sort(struct_processus *s_eta Line 435  instruction_sort(struct_processus *s_eta
                 indice_j = 0;                  indice_j = 0;
                 indice_k = (*((struct_tableau *) (*s_objet_liste).objet))                  indice_k = (*((struct_tableau *) (*s_objet_liste).objet))
                         .nombre_elements - ecartement;                          .nombre_elements - ecartement;
   
                 terminaison_boucle_2 = d_faux;                  terminaison_boucle_2 = d_faux;
   
                 do                  do
Line 557  instruction_sort(struct_processus *s_eta Line 528  instruction_sort(struct_processus *s_eta
   
                             if (condition == d_faux)                              if (condition == d_faux)
                             {                              {
                                 swap((void *) (*((struct_tableau *)                                  s_objet_registre =
                                     (*s_objet_liste).objet)).elements                                          (*((struct_tableau *)
                                     [indice_i - 1], (void *)                                          (*s_objet_liste).objet)).elements
                                     (*((struct_tableau *) (*s_objet_liste)                                          [indice_i - 1];
                                     .objet)).elements[indice_l - 1],                                  (*((struct_tableau *) (*s_objet_liste).objet))
                                     sizeof(struct_objet));                                          .elements[indice_i - 1] =
                                           (*((struct_tableau *) (*s_objet_liste)
                                           .objet)).elements[indice_l - 1];
                                   (*((struct_tableau *) (*s_objet_liste)
                                           .objet)).elements[indice_l - 1] =
                                           s_objet_registre;
   
                                 indice_i -= ecartement;                                  indice_i -= ecartement;
   
Line 599  instruction_sort(struct_processus *s_eta Line 575  instruction_sort(struct_processus *s_eta
     else      else
     {      {
         if (pthread_mutex_unlock(&((*(*s_etat_processus)          if (pthread_mutex_unlock(&((*(*s_etat_processus)
                 .s_liste_variables_partagees).mutex)) != 0)                  .pointeur_variable_partagee_courante).mutex)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 624  instruction_sort(struct_processus *s_eta Line 600  instruction_sort(struct_processus *s_eta
     {      {
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             (*(*s_etat_processus).s_liste_variables_partagees)              (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
                     .table[(*(*s_etat_processus).s_liste_variables_partagees)                      s_objet_liste;
                     .position_variable].objet = s_objet_liste;  
   
             if (pthread_mutex_unlock(&((*(*s_etat_processus)              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                     .s_liste_variables_partagees).mutex)) != 0)                      .pointeur_variable_partagee_courante).mutex)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 658  instruction_sort(struct_processus *s_eta Line 633  instruction_sort(struct_processus *s_eta
 void  void
 instruction_save(struct_processus *s_etat_processus)  instruction_save(struct_processus *s_etat_processus)
 {  {
     logical1                            presence_variable;  
   
     long                                i;  
   
     struct_objet                        *s_objet_1;      struct_objet                        *s_objet_1;
     struct_objet                        *s_objet_2;      struct_objet                        *s_objet_2;
   
Line 686  instruction_save(struct_processus *s_eta Line 657  instruction_save(struct_processus *s_eta
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    1: %s\n", d_NOM);          printf("    1: %s\n", d_NOM);
   
         return;          return;
Line 733  instruction_save(struct_processus *s_eta Line 704  instruction_save(struct_processus *s_eta
         return;          return;
     }      }
   
     if (recherche_variable(s_etat_processus, (*((struct_nom *)      if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
             (*s_objet_1).objet)).nom) == d_vrai)              (*s_objet_1).objet)).nom) == d_vrai)
     {      {
         /*          /*
          * Une variable est accessible directement.           * Une variable est accessible.
          */           */
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].niveau == 1)                  .variable_verrouillee == d_vrai)
         {          {
             // La variable accessible directement est une variable globale.              liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
             if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].variable_verrouillee == d_vrai)  
             {  
                 liberation(s_etat_processus, s_objet_1);  
                 liberation(s_etat_processus, s_objet_2);  
   
                 (*s_etat_processus).erreur_execution =  
                         d_ex_variable_verrouillee;  
                 return;  
             }  
   
             if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].objet == NULL)  
             {  
                 liberation(s_etat_processus, s_objet_1);  
                 liberation(s_etat_processus, s_objet_2);  
   
                 (*s_etat_processus).erreur_execution = d_ex_variable_partagee;  
                 return;  
             }  
   
             liberation(s_etat_processus,              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
                     (*s_etat_processus).s_liste_variables[(*s_etat_processus)              return;
                     .position_variable_courante].objet);  
   
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].objet = s_objet_2;  
         }          }
         else  
         {  
             // On cherche une variable globale de même nom.  
   
             i = (*s_etat_processus).position_variable_courante;  
             presence_variable = d_faux;  
   
             while(i >= 0)  
             {  
                 if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,  
                         (*((struct_nom *) (*s_objet_1).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 ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].niveau == 1)  
             {  
                 // On a trouvé une variable globale correspondant au nom et  
                 // que l'on modifie.  
   
                 if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].variable_verrouillee ==  
                         d_vrai)  
                 {  
                     liberation(s_etat_processus, s_objet_1);  
                     liberation(s_etat_processus, s_objet_2);  
   
                     (*s_etat_processus).erreur_execution =  
                             d_ex_variable_verrouillee;  
                     return;  
                 }  
   
                 if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].objet == NULL)  
                 {  
                     liberation(s_etat_processus, s_objet_1);  
                     liberation(s_etat_processus, s_objet_2);  
   
                     (*s_etat_processus).erreur_execution =  
                             d_ex_variable_partagee;  
                     return;  
                 }  
   
                 liberation(s_etat_processus,  
                         (*s_etat_processus).s_liste_variables  
                         [(*s_etat_processus).position_variable_courante].objet);  
   
                 (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].objet = s_objet_2;  
             }  
             else  
             {  
                 if ((s_variable.nom = malloc((strlen((*((struct_nom *)  
                         (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))  
                         == NULL)  
                 {  
                     (*s_etat_processus).erreur_systeme =  
                             d_es_allocation_memoire;  
                     return;  
                 }  
   
                 strcpy(s_variable.nom, (*((struct_nom *)  
                         (*s_objet_1).objet)).nom);  
                 s_variable.niveau = 1;  
   
                 /*  
                  * Le niveau 0 correspond aux définitions. Les variables  
                  * commencent à 1 car elles sont toujours incluses dans  
                  * une définition.  
                  */  
   
                 s_variable.objet = s_objet_2;          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
   
                 if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')              (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
                         == d_erreur)              return;
                 {  
                     return;  
                 }  
             }  
         }          }
   
           liberation(s_etat_processus,
                   (*(*s_etat_processus).pointeur_variable_courante).objet);
           (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_2;
     }      }
     else      else
     {      {
Line 868  instruction_save(struct_processus *s_eta Line 740  instruction_save(struct_processus *s_eta
          * Aucune variable n'est accessible (ni locale, ni globale).           * Aucune variable n'est accessible (ni locale, ni globale).
          */           */
   
           if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
                   ((*((struct_nom *) (*s_objet_1).objet)).symbole == d_faux))
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
   
               (*s_etat_processus).erreur_systeme = d_es;
               (*s_etat_processus).erreur_execution =
                       d_ex_creation_variable_globale;
               return;
           }
   
         if ((s_variable.nom = malloc((strlen((*((struct_nom *)          if ((s_variable.nom = malloc((strlen((*((struct_nom *)
                 (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))                  (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
                 == NULL)                  == NULL)
Line 917  instruction_save(struct_processus *s_eta Line 801  instruction_save(struct_processus *s_eta
 void  void
 instruction_suspend(struct_processus *s_etat_processus)  instruction_suspend(struct_processus *s_etat_processus)
 {  {
     sigset_t            masque;      struct timespec             attente;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 927  instruction_suspend(struct_processus *s_ Line 811  instruction_suspend(struct_processus *s_
   
         if ((*s_etat_processus).langue == 'F')          if ((*s_etat_processus).langue == 'F')
         {          {
             printf("(attend un signal SIGCONT)\n\n");              printf("(attend un signal RPL/SIGCONT)\n\n");
             printf("  Aucun argument\n");              printf("  Aucun argument\n");
         }          }
         else          else
         {          {
             printf("(wait for SIGCONT signal)\n\n");              printf("(wait for RPL/SIGCONT signal)\n\n");
             printf("  No argument\n");              printf("  No argument\n");
         }          }
   
Line 952  instruction_suspend(struct_processus *s_ Line 836  instruction_suspend(struct_processus *s_
         }          }
     }      }
   
     if (sigfillset(&masque) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (sigdelset(&masque, SIGCONT) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (sigdelset(&masque, SIGFSTOP) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (sigdelset(&masque, SIGURG) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (sigdelset(&masque, SIGALRM) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if ((*s_etat_processus).profilage == d_vrai)      if ((*s_etat_processus).profilage == d_vrai)
     {      {
         profilage(s_etat_processus, "Suspend");          profilage(s_etat_processus, "Suspend");
Line 993  instruction_suspend(struct_processus *s_ Line 847  instruction_suspend(struct_processus *s_
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)          if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
 #   else  #   else
     if (sem_post((*s_etat_processus).semaphore_fork) != 0)          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
     sigsuspend(&masque);      for((*s_etat_processus).redemarrage_processus = d_faux;;)
       {
           scrutation_interruptions(s_etat_processus);
   
           if ((*s_etat_processus).redemarrage_processus == d_vrai)
           {
               break;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
       }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)          while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #   else  #   else
     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #   endif  #   endif
     {      {
         if (errno != EINTR)          if (errno != EINTR)
Line 1290  instruction_swi(struct_processus *s_etat Line 1151  instruction_swi(struct_processus *s_etat
   
     integer8                    interruption;      integer8                    interruption;
   
     pid_t                       pid;  
   
     pthread_t                   tid;  
   
     sig_atomic_t                registre;      sig_atomic_t                registre;
   
     ssize_t                     longueur_ecriture;      ssize_t                     longueur_ecriture;
Line 1302  instruction_swi(struct_processus *s_etat Line 1159  instruction_swi(struct_processus *s_etat
   
     struct timespec             attente;      struct timespec             attente;
   
       unsigned char               caractere;
     unsigned char               tampon;      unsigned char               tampon;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
Line 1370  instruction_swi(struct_processus *s_etat Line 1228  instruction_swi(struct_processus *s_etat
         registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;          registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
         (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;          (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
   
         if ((*s_etat_processus).processus_detache == d_vrai)          interruption_reduite = (int) interruption;
         {  
             pid = -1;  
   
             attente.tv_sec = 0;  
             attente.tv_nsec = GRANULARITE_us * 1000;  
   
 #           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,  
                     (*s_etat_processus).pipe_nombre_objets_attente,  
                     &pid, sizeof(pid))) != sizeof(pid))  
             {  
 #               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 (registre == 0)  
                     {  
                         if ((*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop == -1)  
                         {  
                             (*s_etat_processus).var_volatile_requete_arret = -1;  
                         }  
   
                         (*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop  
                                 = registre;  
                     }  
   
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 nanosleep(&attente, NULL);  
                 INCR_GRANULARITE(attente.tv_nsec);  
   
 #               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;  
                 }  
             }  
   
 #           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;  
                 }  
             }  
         }  
         else  
         {  
             tid = -1;  
   
             attente.tv_sec = 0;  
             attente.tv_nsec = GRANULARITE_us * 1000;  
   
 #           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,  
                     (*s_etat_processus).pipe_nombre_objets_attente,  
                     &tid, sizeof(tid))) != sizeof(tid))  
             {  
 #               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 (registre == 0)  
                     {  
                         if ((*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop == -1)  
                         {  
                             (*s_etat_processus).var_volatile_requete_arret = -1;  
                         }  
   
                         (*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop  
                                 = registre;  
                     }  
   
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 nanosleep(&attente, NULL);  
                 INCR_GRANULARITE(attente.tv_nsec);  
   
 #               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  
             }  
   
 #           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;  
                 }  
             }  
         }  
   
         interruption_reduite = interruption;  
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       endif  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_etat_processus).pipe_interruptions,                  (*s_etat_processus).pipe_interruptions,
Line 1568  instruction_swi(struct_processus *s_etat Line 1249  instruction_swi(struct_processus *s_etat
                 != sizeof(interruption_reduite))                  != sizeof(interruption_reduite))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 1603  instruction_swi(struct_processus *s_etat Line 1284  instruction_swi(struct_processus *s_etat
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           endif  
               scrutation_interruptions(s_etat_processus);
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 1632  instruction_swi(struct_processus *s_etat Line 1311  instruction_swi(struct_processus *s_etat
   
         if ((*s_etat_processus).processus_detache == d_vrai)          if ((*s_etat_processus).processus_detache == d_vrai)
         {          {
             pid = -3;              caractere = 2;
   
             attente.tv_sec = 0;              attente.tv_sec = 0;
             attente.tv_nsec = GRANULARITE_us * 1000;              attente.tv_nsec = GRANULARITE_us * 1000;
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           endif  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_etat_processus).pipe_nombre_interruptions_attente,  
                     &pid, sizeof(pid))) != sizeof(pid))  
             {  
 #               ifndef SEMAPHORES_NOMMES  
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #               else  
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #               endif  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 if (longueur_ecriture == -1)  
                 {  
                     if (registre == 0)  
                     {  
                         if ((*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop == -1)  
                         {  
                             (*s_etat_processus).var_volatile_requete_arret = -1;  
                         }  
   
                         (*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop  
                                 = registre;  
                     }  
   
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 nanosleep(&attente, NULL);  
                 INCR_GRANULARITE(attente.tv_nsec);  
   
 #               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  
             }  
   
             pid = getpid();  
   
             attente.tv_sec = 0;  
             attente.tv_nsec = GRANULARITE_us * 1000;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_etat_processus).pipe_nombre_interruptions_attente,                      (*s_etat_processus).pipe_nombre_elements_attente,
                     &pid, sizeof(pid))) != sizeof(pid))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #               else  #               else
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #               endif  #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
Line 1747  instruction_swi(struct_processus *s_etat Line 1366  instruction_swi(struct_processus *s_etat
                 INCR_GRANULARITE(attente.tv_nsec);                  INCR_GRANULARITE(attente.tv_nsec);
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                      if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
 #               endif  
                   scrutation_interruptions(s_etat_processus);
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 1776  instruction_swi(struct_processus *s_etat Line 1393  instruction_swi(struct_processus *s_etat
         }          }
         else          else
         {          {
             tid = -3;              caractere = 2;
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           endif  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_etat_processus).pipe_nombre_interruptions_attente,                      (*s_etat_processus).pipe_nombre_elements_attente,
                     &tid, sizeof(tid))) != sizeof(tid))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #               else  #               else
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #               endif  #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
Line 1832  instruction_swi(struct_processus *s_etat Line 1445  instruction_swi(struct_processus *s_etat
                 INCR_GRANULARITE(attente.tv_nsec);                  INCR_GRANULARITE(attente.tv_nsec);
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                      if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  #               endif
             }  
   
             tid = pthread_self();  
   
             attente.tv_sec = 0;  
             attente.tv_nsec = GRANULARITE_us * 1000;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_etat_processus).pipe_nombre_interruptions_attente,  
                     &tid, sizeof(tid))) != sizeof(tid))  
             {  
 #               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 (registre == 0)  
                     {  
                         if ((*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop == -1)  
                         {  
                             (*s_etat_processus).var_volatile_requete_arret = -1;  
                         }  
   
                         (*s_etat_processus)  
                                 .var_volatile_traitement_retarde_stop  
                                 = registre;  
                     }  
   
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   
                 nanosleep(&attente, NULL);                  scrutation_interruptions(s_etat_processus);
                 INCR_GRANULARITE(attente.tv_nsec);  
   
 #               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  
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 1924  instruction_swi(struct_processus *s_etat Line 1475  instruction_swi(struct_processus *s_etat
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       endif  
   
         while(read_atomic(s_etat_processus,          while(read_atomic(s_etat_processus,
                 (*s_etat_processus).pipe_acquittement,                  (*s_etat_processus).pipe_acquittement,
                 &tampon, sizeof(unsigned char)) != sizeof(unsigned char))                  &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 1958  instruction_swi(struct_processus *s_etat Line 1505  instruction_swi(struct_processus *s_etat
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
               scrutation_interruptions(s_etat_processus);
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Removed from v.1.9  
changed lines
  Added in v.1.93

CVSweb interface <joel.bertrand@systella.fr>