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

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

version 1.151, 2013/12/03 09:36:16 version 1.156, 2014/05/17 14:06:48
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.17    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 452  rplinit(int argc, char *argv[], char *en Line 451  rplinit(int argc, char *argv[], char *en
   
         if ((*s_etat_processus).langue == 'F')          if ((*s_etat_processus).langue == 'F')
         {          {
             printf("+++Copyright (C) 1989 à 2012, 2013 BERTRAND Joël\n");              printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n");
         }          }
         else          else
         {          {
             printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n");              printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");
         }          }
     }      }
   
Line 496  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 543  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 584  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 633  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 671  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 720  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 758  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 807  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 848  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 895  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 936  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 985  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 1026  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 1075  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 1181  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 1225  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 1276  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 1339  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 1392  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 1435  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 1480  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 1525  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 1569  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 1614  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 1651  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 1688  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 1734  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 1788  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 1833  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 1870  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 1915  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 1960  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 2005  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 2042  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 2094  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 2155  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 2205  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 2245  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 2292  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 2344  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 2405  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 2454  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 2529  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 2576  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 2620  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 2749  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 2792  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 2841  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 2885  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 2941  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 2995  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 3066  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 3110  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 3153  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 3197  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 3240  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 3305  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 3365  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 3632  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 3675  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 3732  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 3822  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 3874  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 3954  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 4010  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 4107  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 4166  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 4253  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 4301  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 4350  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 4398  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 4451  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 4524  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 4594  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 4645  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 4697  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 4761  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 4809  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 4853  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 4902  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 4954  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 5008  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 5057  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 5111  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 5608  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 5671  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 6411  date_compilation() Line 6410  date_compilation()
     return(date);      return(date);
 }  }
   
   #pragma GCC diagnostic pop
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.151  
changed lines
  Added in v.1.156

CVSweb interface <joel.bertrand@systella.fr>