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

Diff for /rpl/src/instructions_s1.c between versions 1.93 and 1.101

version 1.93, 2019/01/01 09:03:09 version 1.101, 2019/02/11 09:45:52
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.30    RPL/2 (R) version 4.1.31
   Copyright (C) 1989-2019 Dr. BERTRAND Joël    Copyright (C) 1989-2019 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 3415  instruction_syseval(struct_processus *s_ Line 3415  instruction_syseval(struct_processus *s_
     unsigned char               *tampon;      unsigned char               *tampon;
   
     integer8                    longueur_lecture;      integer8                    longueur_lecture;
       integer8                    longueur_lue;
     integer8                    longueur_tampon;      integer8                    longueur_tampon;
     integer8                    nombre_iterations;  
     integer8                    nombre_lignes;      integer8                    nombre_lignes;
     integer8                    pointeur;      integer8                    pointeur;
     integer8                    registre_position_courante;      integer8                    registre_position_courante;
Line 3651  instruction_syseval(struct_processus *s_ Line 3651  instruction_syseval(struct_processus *s_
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
   
         action_courante.sa_handler = SIG_IGN;  
         action_courante.sa_flags = SA_NODEFER | SA_ONSTACK;  
   
         if (sigaction(SIGINT, &action_courante, &action_passee) != 0)  
         {  
             for(i = 0; i < nombre_arguments; i++)  
             {  
                 depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),  
                         &s_objet_temporaire);  
                 liberation(s_etat_processus, s_objet_temporaire);  
             }  
   
             free(arguments);  
             (*s_etat_processus).erreur_systeme = d_es_signal;  
             return;  
         }  
   
         if (pipe(pipes_entree) != 0)          if (pipe(pipes_entree) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 3689  instruction_syseval(struct_processus *s_ Line 3672  instruction_syseval(struct_processus *s_
         fflush(NULL);          fflush(NULL);
   
         verrouillage_threads_concurrents(s_etat_processus);          verrouillage_threads_concurrents(s_etat_processus);
   
           action_courante.sa_handler = SIG_IGN;
           action_courante.sa_flags = 0;
   
           if (pthread_mutex_lock(&mutex_sigaction) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if (sigaction(SIGINT, &action_courante, &action_passee) != 0)
           {
               for(i = 0; i < nombre_arguments; i++)
               {
                   depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                           &s_objet_temporaire);
                   liberation(s_etat_processus, s_objet_temporaire);
               }
   
               free(arguments);
               (*s_etat_processus).erreur_systeme = d_es_signal;
               return;
           }
   
         pid = fork();          pid = fork();
   
         if (pid < 0)          if (pid < 0)
Line 3821  instruction_syseval(struct_processus *s_ Line 3828  instruction_syseval(struct_processus *s_
         }          }
         else          else
         {          {
               if (sigaction(SIGINT, &action_passee, NULL) != 0)
               {
                   for(i = 0; i < nombre_arguments; i++)
                   {
                       depilement(s_etat_processus,
                               &((*s_etat_processus).l_base_pile),
                               &s_objet_temporaire);
                       liberation(s_etat_processus, s_objet_temporaire);
                   }
   
                   free(arguments);
                   (*s_etat_processus).erreur_systeme = d_es_signal;
                   return;
               }
   
               if (pthread_mutex_unlock(&mutex_sigaction) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             deverrouillage_threads_concurrents(s_etat_processus);              deverrouillage_threads_concurrents(s_etat_processus);
   
             if (close(pipes_entree[0]) != 0)              if (close(pipes_entree[0]) != 0)
Line 3967  instruction_syseval(struct_processus *s_ Line 3995  instruction_syseval(struct_processus *s_
                 return;                  return;
             }              }
   
             do              longueur_lecture = 65536;
             {              longueur_lue = 0;
                 if (kill(pid, 0) != 0)  
                 {  
                     break;  
                 }  
   
                 /*  
                  * Récupération de la valeur de retour du processus détaché  
                  */  
   
 #               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(waitpid(pid, &status, 0) == -1)  
                 {  
                     if (errno != EINTR)  
                     {  
 #                       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;  
                         }  
   
                         (*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;  
                     }  
                 }  
             } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));  
   
             longueur_lecture = 256;  
             pointeur = 0;              pointeur = 0;
             nombre_iterations = 1;  
   
             if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *              if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
Line 4060  instruction_syseval(struct_processus *s_ Line 4032  instruction_syseval(struct_processus *s_
                     return;                      return;
                 }                  }
   
                   longueur_lue += ios;
                 tampon[pointeur + ios] = d_code_fin_chaine;                  tampon[pointeur + ios] = d_code_fin_chaine;
                 pointeur += longueur_lecture;                  pointeur += ios;
                 nombre_iterations++;  
   
                 if ((tampon = realloc(tampon,                  if ((tampon = realloc(tampon,
                         ((size_t) ((nombre_iterations * longueur_lecture) + 1))                          ((size_t) ((longueur_lue + longueur_lecture) + 1))
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 4097  instruction_syseval(struct_processus *s_ Line 4069  instruction_syseval(struct_processus *s_
                 }                  }
             }              }
   
               do
               {
                   if (kill(pid, 0) != 0)
                   {
                       // Le processus n'existe plus.
                       break;
                   }
   
                   /*
                    * Récupération de la valeur de retour du processus détaché
                    */
   
   #               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(waitpid(pid, &status, 0) == -1)
                   {
                       if (errno != EINTR)
                       {
                           (*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;
                       }
                   }
               } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
   
             if (ios == -1)              if (ios == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 4199  instruction_syseval(struct_processus *s_ Line 4216  instruction_syseval(struct_processus *s_
             free(tampon);              free(tampon);
         }          }
   
         if (sigaction(SIGINT, &action_passee, NULL) != 0)  
         {  
             for(i = 0; i < nombre_arguments; i++)  
             {  
                 depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),  
                         &s_objet_temporaire);  
                 liberation(s_etat_processus, s_objet_temporaire);  
             }  
   
             free(arguments);  
             (*s_etat_processus).erreur_systeme = d_es_signal;  
             return;  
         }  
   
         for(i = 0; i < nombre_arguments; i++)          for(i = 0; i < nombre_arguments; i++)
         {          {
             depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),              depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
Line 4220  instruction_syseval(struct_processus *s_ Line 4223  instruction_syseval(struct_processus *s_
             liberation(s_etat_processus, s_objet_temporaire);              liberation(s_etat_processus, s_objet_temporaire);
         }          }
   
           free(arguments);
   
         if ((tampon = malloc(sizeof(unsigned char))) == NULL)          if ((tampon = malloc(sizeof(unsigned char))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4289  instruction_syseval(struct_processus *s_ Line 4294  instruction_syseval(struct_processus *s_
             return;              return;
         }          }
   
         free(arguments);  
         free(tampon);          free(tampon);
     }      }
     else      else
Removed from v.1.93  
changed lines
  Added in v.1.101

CVSweb interface <joel.bertrand@systella.fr>