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

Diff for /rpl/src/instructions_d5.c between versions 1.100 and 1.111

version 1.100, 2012/12/19 09:58:24 version 1.111, 2013/05/28 22:09:55
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.14
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 40  instruction_dft(struct_processus *s_etat Line 40  instruction_dft(struct_processus *s_etat
 {  {
     integer4                    erreur;      integer4                    erreur;
     integer4                    inverse;      integer4                    inverse;
       integer4                    longueur_dft;
     integer4                    nombre_colonnes;      integer4                    nombre_colonnes;
     integer4                    nombre_lignes;      integer4                    nombre_lignes;
   
     logical1                    presence_longueur_dft;      logical1                    presence_longueur_dft;
   
     long                        longueur_dft_signee;      integer8                    longueur_dft_signee;
   
     struct_complexe16           *matrice_f77;      struct_complexe16           *matrice_f77;
   
Line 53  instruction_dft(struct_processus *s_etat Line 54  instruction_dft(struct_processus *s_etat
     struct_objet                *s_objet_longueur_dft;      struct_objet                *s_objet_longueur_dft;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
     unsigned long               k;      integer8                    k;
     unsigned long               longueur_dft;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 135  instruction_dft(struct_processus *s_etat Line 135  instruction_dft(struct_processus *s_etat
             return;              return;
         }          }
   
         longueur_dft = longueur_dft_signee;          longueur_dft = (integer4) longueur_dft_signee;
     }      }
     else      else
     {      {
Line 170  instruction_dft(struct_processus *s_etat Line 170  instruction_dft(struct_processus *s_etat
     {      {
         if (presence_longueur_dft == d_faux)          if (presence_longueur_dft == d_faux)
         {          {
             longueur_dft = (*((struct_vecteur *)              longueur_dft = (integer4) (*((struct_vecteur *)
                     (*s_objet_argument).objet)).taille;                      (*s_objet_argument).objet)).taille;
         }          }
   
         if ((matrice_f77 = malloc(longueur_dft *          if ((matrice_f77 = malloc(((size_t) longueur_dft) *
                 sizeof(struct_complexe16))) == NULL)                  sizeof(struct_complexe16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 260  instruction_dft(struct_processus *s_etat Line 260  instruction_dft(struct_processus *s_etat
     {      {
         if (presence_longueur_dft == d_faux)          if (presence_longueur_dft == d_faux)
         {          {
             longueur_dft = (*((struct_matrice *)              longueur_dft = (integer4) (*((struct_matrice *)
                     (*s_objet_argument).objet)).nombre_colonnes;                      (*s_objet_argument).objet)).nombre_colonnes;
         }          }
   
         if ((matrice_f77 = malloc(longueur_dft *          if ((matrice_f77 = malloc(((size_t) longueur_dft) * ((size_t)
                 (*((struct_matrice *) (*s_objet_argument).objet))                  (*((struct_matrice *) (*s_objet_argument).objet))
                 .nombre_lignes * sizeof(struct_complexe16))) == NULL)                  .nombre_lignes) * sizeof(struct_complexe16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 342  instruction_dft(struct_processus *s_etat Line 342  instruction_dft(struct_processus *s_etat
             }              }
         }          }
   
         nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet))          nombre_lignes = (integer4) (*((struct_matrice *) (*s_objet_argument)
                 .nombre_lignes;                  .objet)).nombre_lignes;
         nombre_colonnes = longueur_dft;          nombre_colonnes = longueur_dft;
         inverse = 0;          inverse = 0;
   
Line 371  instruction_dft(struct_processus *s_etat Line 371  instruction_dft(struct_processus *s_etat
                 longueur_dft;                  longueur_dft;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *) (*s_objet_resultat).objet))                  malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
                 .nombre_lignes * sizeof(struct_complexe16 *))) == NULL)                  .objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 383  instruction_dft(struct_processus *s_etat Line 383  instruction_dft(struct_processus *s_etat
         {          {
             if ((((struct_complexe16 **) (*((struct_matrice *)              if ((((struct_complexe16 **) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).tableau)[i] =                      (*s_objet_resultat).objet)).tableau)[i] =
                     malloc((*((struct_matrice *)                      malloc(((size_t) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).nombre_colonnes *                      (*s_objet_resultat).objet)).nombre_colonnes) *
                     sizeof(struct_complexe16))) == NULL)                      sizeof(struct_complexe16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 819  instruction_detach(struct_processus *s_e Line 819  instruction_detach(struct_processus *s_e
     logical1                            drapeau;      logical1                            drapeau;
   
     pid_t                               ppid;      pid_t                               ppid;
     pid_t                               pid_final;  
   
     pthread_attr_t                      attributs;      pthread_attr_t                      attributs;
   
Line 859  instruction_detach(struct_processus *s_e Line 858  instruction_detach(struct_processus *s_e
   
     unsigned int                        erreur;      unsigned int                        erreur;
   
     unsigned long                       i;      integer8                            i;
   
     volatile logical1                   variable_partagee;      volatile logical1                   variable_partagee;
   
Line 1040  instruction_detach(struct_processus *s_e Line 1039  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
     if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)      if (pipe((*s_argument_thread).pipe_nombre_elements_attente) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 1058  instruction_detach(struct_processus *s_e Line 1057  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
     if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (pipe((*s_argument_thread).pipe_injections) != 0)      if (pipe((*s_argument_thread).pipe_injections) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1172  instruction_detach(struct_processus *s_e Line 1165  instruction_detach(struct_processus *s_e
             return;              return;
         }          }
   
         if (close((*s_argument_thread).pipe_nombre_interruptions_attente[1])          if (close((*s_argument_thread).pipe_nombre_elements_attente[1])
                 != 0)                  != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1185  instruction_detach(struct_processus *s_e Line 1178  instruction_detach(struct_processus *s_e
             return;              return;
         }          }
   
         if (close((*s_argument_thread).pipe_nombre_objets_attente[1]) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
   
         if (close((*s_argument_thread).pipe_injections[0]) != 0)          if (close((*s_argument_thread).pipe_injections[0]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1317  instruction_detach(struct_processus *s_e Line 1304  instruction_detach(struct_processus *s_e
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
         else if (close((*s_argument_thread)          else if (close((*s_argument_thread)
                 .pipe_nombre_interruptions_attente[0]) != 0)                  .pipe_nombre_elements_attente[0]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
Line 1325  instruction_detach(struct_processus *s_e Line 1312  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
         else if (close((*s_argument_thread).pipe_nombre_objets_attente[0]) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
         }  
         else if (close((*s_argument_thread).pipe_injections[1]) != 0)          else if (close((*s_argument_thread).pipe_injections[1]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1376  instruction_detach(struct_processus *s_e Line 1359  instruction_detach(struct_processus *s_e
         // Envoi d'une donnée pour signaler le démarrage du processus au thread          // Envoi d'une donnée pour signaler le démarrage du processus au thread
         // de surveillance.          // de surveillance.
   
           caractere = 0;
   
         if (write_atomic(s_etat_processus,          if (write_atomic(s_etat_processus,
                 (*s_argument_thread).pipe_nombre_objets_attente[1],                  (*s_argument_thread).pipe_nombre_elements_attente[1],
                 "-", sizeof(unsigned char)) != sizeof(unsigned char))                  &caractere, sizeof(caractere)) != sizeof(caractere))
         {          {
             pthread_mutex_unlock(&((*s_etat_processus).mutex));              pthread_mutex_unlock(&((*s_etat_processus).mutex));
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_final = -2;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1414  instruction_detach(struct_processus *s_e Line 1387  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_final = -2;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1450  instruction_detach(struct_processus *s_e Line 1411  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_objets_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1484  instruction_detach(struct_processus *s_e Line 1435  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1496  instruction_detach(struct_processus *s_e Line 1447  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               destruction_queue_signaux(s_etat_processus);
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
           pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions));
   
           if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))
                   != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
   
               caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1583  instruction_detach(struct_processus *s_e Line 1548  instruction_detach(struct_processus *s_e
         (*s_etat_processus).presence_pipes = d_vrai;          (*s_etat_processus).presence_pipes = d_vrai;
         (*s_etat_processus).debug_programme = d_faux;          (*s_etat_processus).debug_programme = d_faux;
         (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];          (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];
         (*s_etat_processus).pipe_nombre_objets_attente = (*s_argument_thread)          (*s_etat_processus).pipe_nombre_elements_attente = (*s_argument_thread)
                 .pipe_nombre_objets_attente[1];                  .pipe_nombre_elements_attente[1];
         (*s_etat_processus).pipe_interruptions = (*s_argument_thread)          (*s_etat_processus).pipe_interruptions = (*s_argument_thread)
                 .pipe_interruptions[1];                  .pipe_interruptions[1];
         (*s_etat_processus).pipe_nombre_interruptions_attente =  
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1];  
         (*s_etat_processus).pipe_injections =          (*s_etat_processus).pipe_injections =
                 (*s_argument_thread).pipe_injections[0];                  (*s_argument_thread).pipe_injections[0];
         (*s_etat_processus).pipe_nombre_injections =          (*s_etat_processus).pipe_nombre_injections =
Line 1602  instruction_detach(struct_processus *s_e Line 1565  instruction_detach(struct_processus *s_e
         (*s_etat_processus).thread_fusible = 0;          (*s_etat_processus).thread_fusible = 0;
         (*s_etat_processus).pid_erreur_processus_fils = getpid();          (*s_etat_processus).pid_erreur_processus_fils = getpid();
         (*s_etat_processus).sections_critiques = 0;          (*s_etat_processus).sections_critiques = 0;
           (*s_etat_processus).initialisation_scheduler = d_faux;
   
         if ((*s_etat_processus).profilage == d_vrai)          if ((*s_etat_processus).profilage == d_vrai)
         {          {
Line 1632  instruction_detach(struct_processus *s_e Line 1596  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es;              (*s_etat_processus).erreur_systeme = d_es;
   
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_objets_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1681  instruction_detach(struct_processus *s_e Line 1635  instruction_detach(struct_processus *s_e
                 close((*s_argument_thread2).pipe_acquittement[1]);                  close((*s_argument_thread2).pipe_acquittement[1]);
                 close((*s_argument_thread2).pipe_injections[1]);                  close((*s_argument_thread2).pipe_injections[1]);
                 close((*s_argument_thread2).pipe_nombre_injections[1]);                  close((*s_argument_thread2).pipe_nombre_injections[1]);
                 close((*s_argument_thread2).pipe_nombre_objets_attente[0]);                  close((*s_argument_thread2).pipe_nombre_elements_attente[0]);
                 close((*s_argument_thread2).pipe_interruptions[0]);                  close((*s_argument_thread2).pipe_interruptions[0]);
                 close((*s_argument_thread2)  
                         .pipe_nombre_interruptions_attente[0]);  
   
                 pthread_mutex_destroy(&((*s_argument_thread2).mutex));                  pthread_mutex_destroy(&((*s_argument_thread2).mutex));
   
Line 1713  instruction_detach(struct_processus *s_e Line 1665  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es;              (*s_etat_processus).erreur_systeme = d_es;
   
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_objets_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1778  instruction_detach(struct_processus *s_e Line 1720  instruction_detach(struct_processus *s_e
   
         if ((*s_etat_processus).erreur_systeme != d_es)          if ((*s_etat_processus).erreur_systeme != d_es)
         {          {
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_objets_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1831  instruction_detach(struct_processus *s_e Line 1763  instruction_detach(struct_processus *s_e
   
         if ((*s_etat_processus).erreur_systeme != d_es)          if ((*s_etat_processus).erreur_systeme != d_es)
         {          {
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1999  instruction_detach(struct_processus *s_e Line 1921  instruction_detach(struct_processus *s_e
                     }                      }
                     else                      else
                     {                      {
                         if (((*s_etat_processus).var_volatile_alarme == 0)                          if (((*s_etat_processus).arret_depuis_abort == 0)
                                 && ((*s_etat_processus).arret_depuis_abort == 0)  
                                 && ((*s_etat_processus).at_exit != NULL))                                  && ((*s_etat_processus).at_exit != NULL))
                         {                          {
                             (*s_etat_processus).var_volatile_requete_arret = 0;                              (*s_etat_processus).var_volatile_requete_arret = 0;
                               (*s_etat_processus).var_volatile_alarme = 0;
                               (*s_etat_processus).var_volatile_traitement_sigint
                                       = 0;
   
                               if ((*s_etat_processus).profilage == d_vrai)
                               {
                                   profilage(s_etat_processus, "ATEXIT");
                               }
   
                             if (evaluation(s_etat_processus,                              if (evaluation(s_etat_processus,
                                     (*s_etat_processus).at_exit, 'E') ==                                      (*s_etat_processus).at_exit, 'E') ==
Line 2012  instruction_detach(struct_processus *s_e Line 1941  instruction_detach(struct_processus *s_e
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_erreur_evaluation;                                          d_ex_erreur_evaluation;
                             }                              }
   
                               if ((*s_etat_processus).profilage == d_vrai)
                               {
                                   profilage(s_etat_processus, NULL);
                               }
                         }                          }
                     }                      }
                 }                  }
Line 2028  instruction_detach(struct_processus *s_e Line 1962  instruction_detach(struct_processus *s_e
                     }                      }
                     else                      else
                     {                      {
                         if (((*s_etat_processus).var_volatile_alarme == 0)                          if (((*s_etat_processus).arret_depuis_abort == 0)
                                 && ((*s_etat_processus).arret_depuis_abort == 0)  
                                 && ((*s_etat_processus).at_exit != NULL))                                  && ((*s_etat_processus).at_exit != NULL))
                         {                          {
                             (*s_etat_processus).var_volatile_requete_arret = 0;                              (*s_etat_processus).var_volatile_requete_arret = 0;
                               (*s_etat_processus).var_volatile_alarme = 0;
                               (*s_etat_processus).var_volatile_traitement_sigint
                                       = 0;
   
                               if ((*s_etat_processus).profilage == d_vrai)
                               {
                                   profilage(s_etat_processus, "ATEXIT");
                               }
   
                             if (evaluation(s_etat_processus,                              if (evaluation(s_etat_processus,
                                     (*s_etat_processus).at_exit, 'E') ==                                      (*s_etat_processus).at_exit, 'E') ==
Line 2041  instruction_detach(struct_processus *s_e Line 1982  instruction_detach(struct_processus *s_e
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_erreur_evaluation;                                          d_ex_erreur_evaluation;
                             }                              }
   
                               if ((*s_etat_processus).profilage == d_vrai)
                               {
                                   profilage(s_etat_processus, NULL);
                               }
                         }                          }
                     }                      }
   
Line 2073  instruction_detach(struct_processus *s_e Line 2019  instruction_detach(struct_processus *s_e
             pthread_cancel((*s_etat_processus).thread_fusible);              pthread_cancel((*s_etat_processus).thread_fusible);
         }          }
   
         pid_final = -2;          caractere = 0;
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                 &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
         {  
             if (longueur_ecriture == -1)  
             {  
                 break;  
             }  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_argument_thread).pipe_nombre_objets_attente[1],                  (*s_argument_thread).pipe_nombre_elements_attente[1],
                 &pid_final, sizeof(pid_final))) != sizeof(pid_final))                  &caractere, sizeof(caractere))) != sizeof(caractere))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2116  instruction_detach(struct_processus *s_e Line 2052  instruction_detach(struct_processus *s_e
         {          {
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_erreurs[1],                      (*s_argument_thread).pipe_erreurs[1],
                     &((*s_etat_processus).erreur_execution),                      (int *) &((*s_etat_processus).erreur_execution),
                     sizeof((*s_etat_processus).erreur_execution))) !=                      sizeof((*s_etat_processus).erreur_execution))) !=
                     sizeof((*s_etat_processus).erreur_execution))                      sizeof((*s_etat_processus).erreur_execution))
             {              {
Line 2148  instruction_detach(struct_processus *s_e Line 2084  instruction_detach(struct_processus *s_e
         {          {
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_erreurs[1],                      (*s_argument_thread).pipe_erreurs[1],
                     &((*s_etat_processus).erreur_systeme),                      (int *) &((*s_etat_processus).erreur_systeme),
                     sizeof((*s_etat_processus).erreur_systeme))) !=                      sizeof((*s_etat_processus).erreur_systeme))) !=
                     sizeof((*s_etat_processus).erreur_systeme))                      sizeof((*s_etat_processus).erreur_systeme))
             {              {
Line 2188  instruction_detach(struct_processus *s_e Line 2124  instruction_detach(struct_processus *s_e
   
         close((*s_argument_thread).pipe_erreurs[1]);          close((*s_argument_thread).pipe_erreurs[1]);
         close((*s_argument_thread).pipe_interruptions[1]);          close((*s_argument_thread).pipe_interruptions[1]);
         close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);          close((*s_argument_thread).pipe_nombre_elements_attente[1]);
         close((*s_argument_thread).pipe_objets[1]);          close((*s_argument_thread).pipe_objets[1]);
         close((*s_argument_thread).pipe_nombre_objets_attente[1]);  
         close((*s_argument_thread).pipe_injections[0]);          close((*s_argument_thread).pipe_injections[0]);
         close((*s_argument_thread).pipe_nombre_injections[0]);          close((*s_argument_thread).pipe_nombre_injections[0]);
         close((*s_argument_thread).pipe_acquittement[0]);          close((*s_argument_thread).pipe_acquittement[0]);
Line 2377  instruction_detach(struct_processus *s_e Line 2312  instruction_detach(struct_processus *s_e
                     .var_volatile_traitement_retarde_stop;                      .var_volatile_traitement_retarde_stop;
             (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;              (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
   
             for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *)              for(i = 0; i < (*(*((struct_processus_fils *)
                     (*(*l_element_courant)                      (*(*l_element_courant)
                     .donnee).objet)).thread).nombre_objets_dans_pipe; i++)                      .donnee).objet)).thread).nombre_objets_dans_pipe; i++)
             {              {
Line 2456  instruction_detach(struct_processus *s_e Line 2391  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
             pthread_mutex_unlock(&((*s_etat_processus).mutex));              if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions))
                       != 0)
               {
                   destruction_queue_signaux(s_etat_processus);
   
                   pthread_mutex_unlock(&((*s_etat_processus).mutex));
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   exit(EXIT_FAILURE);
               }
   
             if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)              if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  affectation_interruptions_logicielles(s_etat_processus);
             }              }
   
               if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_interruptions)) != 0)
               {
                   destruction_queue_signaux(s_etat_processus);
   
                   pthread_mutex_unlock(&((*s_etat_processus).mutex));
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   exit(EXIT_FAILURE);
               }
   
               pthread_mutex_unlock(&((*s_etat_processus).mutex));
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             pthread_mutex_lock(&((*s_etat_processus).mutex));              pthread_mutex_lock(&((*s_etat_processus).mutex));
   
Line 2794  instruction_detach(struct_processus *s_e Line 2748  instruction_detach(struct_processus *s_e
   
         pthread_mutex_destroy(&((*s_etat_processus).mutex));          pthread_mutex_destroy(&((*s_etat_processus).mutex));
         pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));          pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
           pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
         pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));          pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
         pthread_mutex_destroy(&mutex_sections_critiques);          pthread_mutex_destroy(&mutex_sections_critiques);
   
Removed from v.1.100  
changed lines
  Added in v.1.111

CVSweb interface <joel.bertrand@systella.fr>