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

Diff for /rpl/src/rpl.c between versions 1.148 and 1.156

version 1.148, 2013/08/27 13:48:05 version 1.156, 2014/05/17 14:06:48
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.15    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 23 Line 23
 #define  MAIN_RPL  #define  MAIN_RPL
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   // Bug de gcc à partir de gcc 4.6 (bug 48544)
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wclobbered"
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 298  rplinit(int argc, char *argv[], char *en Line 302  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 345  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 383  rplinit(int argc, char *argv[], char *en Line 382  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 422  rplinit(int argc, char *argv[], char *en Line 421  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 443  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 495  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 542  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 583  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 632  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 670  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 719  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 757  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 806  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 847  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 894  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 935  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 984  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 1025  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 1074  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 1180  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 1224  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 1275  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 1338  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 1391  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 1434  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 1479  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 1524  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 1568  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 1613  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 1650  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 1687  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 1733  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 1787  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 1832  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 1869  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 1914  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 1959  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 2004  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 2041  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 2093  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 2154  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 2204  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 2244  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 2291  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 2343  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 2404  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 2453  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 2528  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 2575  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 2619  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 2748  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 2791  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 2840  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 2884  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 2940  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 2994  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 3065  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 3109  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 3152  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 3196  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 3239  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 3304  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 3364  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 3631  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 3674  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 3731  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 3821  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 3873  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 3953  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 4009  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 4106  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 4165  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 4252  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 4300  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 4349  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 4397  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 4450  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 4523  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 4593  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 4644  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 4696  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 4760  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 4808  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 4852  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 4901  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 4953  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 5007  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 5056  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 5110  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 5607  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 5670  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 6407  date_compilation() Line 6410  date_compilation()
     return(date);      return(date);
 }  }
   
   #pragma GCC diagnostic pop
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.148  
changed lines
  Added in v.1.156

CVSweb interface <joel.bertrand@systella.fr>