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

Diff for /rpl/src/rpl.c between versions 1.146 and 1.155

version 1.146, 2013/05/30 09:41:42 version 1.155, 2014/04/25 08:18:59
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.14    RPL/2 (R) version 4.1.18
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2014 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 298  rplinit(int argc, char *argv[], char *en Line 298  rplinit(int argc, char *argv[], char *en
         if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
                 pthread_self(), SEM_FORK)) == SEM_FAILED)                  pthread_self(), SEM_FORK)) == SEM_FAILED)
         {          {
 #           ifndef SEMAPHORES_NOMMES              sem_post(semaphore_gestionnaires_signaux);
                 sem_post(&semaphore_gestionnaires_signaux);              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                 sem_destroy(&semaphore_gestionnaires_signaux);                      SEM_SIGNAUX);
 #           else  
                 sem_post(semaphore_gestionnaires_signaux);  
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),  
                         SEM_SIGNAUX);  
 #           endif  
   
             liberation(contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
   
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
Line 346  rplinit(int argc, char *argv[], char *en Line 341  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 370  rplinit(int argc, char *argv[], char *en Line 365  rplinit(int argc, char *argv[], char *en
     }      }
     else      else
     {      {
 #       ifndef SEMAPHORES_NOMMES  
             sem_post(&((*s_etat_processus).semaphore_fork));  
             sem_post(&semaphore_gestionnaires_signaux);  
             sem_destroy(&semaphore_gestionnaires_signaux);  
             sem_destroy(&((*s_etat_processus).semaphore_fork));  
 #       else  
             sem_post((*s_etat_processus).semaphore_fork);  
             sem_post(semaphore_gestionnaires_signaux);  
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),  
                     SEM_SIGNAUX);  
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),  
                     pthread_self(), SEM_FORK);  
 #       endif  
   
         liberation_contexte_cas(s_etat_processus);  
         liberation_queue_signaux(s_etat_processus);  
   
         if (((*s_etat_processus).localisation = malloc((strlen(d_locale)          if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
                 + 1) * sizeof(unsigned char))) == NULL)                  + 1) * sizeof(unsigned char))) == NULL)
         {          {
   #           ifndef SEMAPHORES_NOMMES
                   sem_post(&((*s_etat_processus).semaphore_fork));
                   sem_post(&semaphore_gestionnaires_signaux);
                   sem_destroy(&semaphore_gestionnaires_signaux);
                   sem_destroy(&((*s_etat_processus).semaphore_fork));
   #           else
                   sem_post((*s_etat_processus).semaphore_fork);
                   sem_post(semaphore_gestionnaires_signaux);
                   sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                           SEM_SIGNAUX);
                   sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                           pthread_self(), SEM_FORK);
   #           endif
   
               liberation_contexte_cas(s_etat_processus);
               liberation_queue_signaux(s_etat_processus);
   
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 uprintf("+++Système : Mémoire insuffisante\n");                  uprintf("+++Système : Mémoire insuffisante\n");
Line 422  rplinit(int argc, char *argv[], char *en Line 417  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),                  sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                         SEM_SIGNAUX);                          SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork, getpid(),                  sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                         pthread_self(), SEM_FORK);                          pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 444  rplinit(int argc, char *argv[], char *en Line 439  rplinit(int argc, char *argv[], char *en
         strcpy((*s_etat_processus).localisation, d_locale);          strcpy((*s_etat_processus).localisation, d_locale);
     }      }
   
     printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,      if (resultats == NULL) // Appel direct
             ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);  
   
     if ((*s_etat_processus).langue == 'F')  
     {      {
         printf("+++Copyright (C) 1989 à 2012, 2013 BERTRAND Joël\n");          printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
     }                  ((*s_etat_processus).langue == 'F')
     else                  ? d_date_rpl : d_date_en_rpl);
     {  
         printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n");          if ((*s_etat_processus).langue == 'F')
           {
               printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n");
           }
           else
           {
               printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");
           }
     }      }
   
     if (getenv("HOME") != NULL)      if (getenv("HOME") != NULL)
Line 492  rplinit(int argc, char *argv[], char *en Line 491  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),                  sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                         SEM_SIGNAUX);                          SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork, getpid(),                  sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                         pthread_self(), SEM_FORK);                          pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 539  rplinit(int argc, char *argv[], char *en Line 538  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 580  rplinit(int argc, char *argv[], char *en Line 579  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 629  rplinit(int argc, char *argv[], char *en Line 628  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 667  rplinit(int argc, char *argv[], char *en Line 666  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 716  rplinit(int argc, char *argv[], char *en Line 715  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 754  rplinit(int argc, char *argv[], char *en Line 753  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 803  rplinit(int argc, char *argv[], char *en Line 802  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 844  rplinit(int argc, char *argv[], char *en Line 843  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 891  rplinit(int argc, char *argv[], char *en Line 890  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 932  rplinit(int argc, char *argv[], char *en Line 931  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 981  rplinit(int argc, char *argv[], char *en Line 980  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1022  rplinit(int argc, char *argv[], char *en Line 1021  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1071  rplinit(int argc, char *argv[], char *en Line 1070  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1177  rplinit(int argc, char *argv[], char *en Line 1176  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1221  rplinit(int argc, char *argv[], char *en Line 1220  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1272  rplinit(int argc, char *argv[], char *en Line 1271  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 1335  rplinit(int argc, char *argv[], char *en Line 1334  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 1388  rplinit(int argc, char *argv[], char *en Line 1387  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1431  rplinit(int argc, char *argv[], char *en Line 1430  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1476  rplinit(int argc, char *argv[], char *en Line 1475  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1521  rplinit(int argc, char *argv[], char *en Line 1520  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1565  rplinit(int argc, char *argv[], char *en Line 1564  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1610  rplinit(int argc, char *argv[], char *en Line 1609  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1647  rplinit(int argc, char *argv[], char *en Line 1646  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1684  rplinit(int argc, char *argv[], char *en Line 1683  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1730  rplinit(int argc, char *argv[], char *en Line 1729  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1784  rplinit(int argc, char *argv[], char *en Line 1783  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1829  rplinit(int argc, char *argv[], char *en Line 1828  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1866  rplinit(int argc, char *argv[], char *en Line 1865  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1911  rplinit(int argc, char *argv[], char *en Line 1910  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1956  rplinit(int argc, char *argv[], char *en Line 1955  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2001  rplinit(int argc, char *argv[], char *en Line 2000  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2038  rplinit(int argc, char *argv[], char *en Line 2037  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2090  rplinit(int argc, char *argv[], char *en Line 2089  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2151  rplinit(int argc, char *argv[], char *en Line 2150  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2201  rplinit(int argc, char *argv[], char *en Line 2200  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2241  rplinit(int argc, char *argv[], char *en Line 2240  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2288  rplinit(int argc, char *argv[], char *en Line 2287  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2340  rplinit(int argc, char *argv[], char *en Line 2339  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2401  rplinit(int argc, char *argv[], char *en Line 2400  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2450  rplinit(int argc, char *argv[], char *en Line 2449  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2525  rplinit(int argc, char *argv[], char *en Line 2524  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                       endif  #                                       endif
   
Line 2572  rplinit(int argc, char *argv[], char *en Line 2571  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2616  rplinit(int argc, char *argv[], char *en Line 2615  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2745  rplinit(int argc, char *argv[], char *en Line 2744  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2788  rplinit(int argc, char *argv[], char *en Line 2787  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2837  rplinit(int argc, char *argv[], char *en Line 2836  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2881  rplinit(int argc, char *argv[], char *en Line 2880  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2937  rplinit(int argc, char *argv[], char *en Line 2936  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2991  rplinit(int argc, char *argv[], char *en Line 2990  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3062  rplinit(int argc, char *argv[], char *en Line 3061  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3106  rplinit(int argc, char *argv[], char *en Line 3105  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3149  rplinit(int argc, char *argv[], char *en Line 3148  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3193  rplinit(int argc, char *argv[], char *en Line 3192  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3236  rplinit(int argc, char *argv[], char *en Line 3235  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3301  rplinit(int argc, char *argv[], char *en Line 3300  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux,                  sem_destroy2(semaphore_gestionnaires_signaux,
                         getpid(), SEM_SIGNAUX);                          getpid(), SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork,                  sem_destroy3((*s_etat_processus).semaphore_fork,
                         getpid(), pthread_self(), SEM_FORK);                          getpid(), pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 3361  rplinit(int argc, char *argv[], char *en Line 3360  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux,                  sem_destroy2(semaphore_gestionnaires_signaux,
                         getpid(), SEM_SIGNAUX);                          getpid(), SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork,                  sem_destroy3((*s_etat_processus).semaphore_fork,
                         getpid(), pthread_self(), SEM_FORK);                          getpid(), pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 3628  rplinit(int argc, char *argv[], char *en Line 3627  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3671  rplinit(int argc, char *argv[], char *en Line 3670  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3728  rplinit(int argc, char *argv[], char *en Line 3727  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3818  rplinit(int argc, char *argv[], char *en Line 3817  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 3870  rplinit(int argc, char *argv[], char *en Line 3869  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 3950  rplinit(int argc, char *argv[], char *en Line 3949  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4006  rplinit(int argc, char *argv[], char *en Line 4005  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4103  rplinit(int argc, char *argv[], char *en Line 4102  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4162  rplinit(int argc, char *argv[], char *en Line 4161  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4249  rplinit(int argc, char *argv[], char *en Line 4248  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4297  rplinit(int argc, char *argv[], char *en Line 4296  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4346  rplinit(int argc, char *argv[], char *en Line 4345  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4394  rplinit(int argc, char *argv[], char *en Line 4393  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4447  rplinit(int argc, char *argv[], char *en Line 4446  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4520  rplinit(int argc, char *argv[], char *en Line 4519  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4590  rplinit(int argc, char *argv[], char *en Line 4589  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4641  rplinit(int argc, char *argv[], char *en Line 4640  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4693  rplinit(int argc, char *argv[], char *en Line 4692  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4757  rplinit(int argc, char *argv[], char *en Line 4756  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4805  rplinit(int argc, char *argv[], char *en Line 4804  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4849  rplinit(int argc, char *argv[], char *en Line 4848  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4898  rplinit(int argc, char *argv[], char *en Line 4897  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4950  rplinit(int argc, char *argv[], char *en Line 4949  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5004  rplinit(int argc, char *argv[], char *en Line 5003  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 5053  rplinit(int argc, char *argv[], char *en Line 5052  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5107  rplinit(int argc, char *argv[], char *en Line 5106  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 5604  rplinit(int argc, char *argv[], char *en Line 5603  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5667  rplinit(int argc, char *argv[], char *en Line 5666  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Removed from v.1.146  
changed lines
  Added in v.1.155

CVSweb interface <joel.bertrand@systella.fr>