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

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

version 1.153, 2014/03/15 11:04:44 version 1.155, 2014/04/25 08:18:59
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.17    RPL/2 (R) version 4.1.18
   Copyright (C) 1989-2014 Dr. BERTRAND Joël    Copyright (C) 1989-2014 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 298  rplinit(int argc, char *argv[], char *en Line 298  rplinit(int argc, char *argv[], char *en
         if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
                 pthread_self(), SEM_FORK)) == SEM_FAILED)                  pthread_self(), SEM_FORK)) == SEM_FAILED)
         {          {
 #           ifndef SEMAPHORES_NOMMES              sem_post(semaphore_gestionnaires_signaux);
                 sem_post(&semaphore_gestionnaires_signaux);              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                 sem_destroy(&semaphore_gestionnaires_signaux);                      SEM_SIGNAUX);
 #           else  
                 sem_post(semaphore_gestionnaires_signaux);  
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),  
                         SEM_SIGNAUX);  
 #           endif  
   
             liberation(contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
   
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
Line 346  rplinit(int argc, char *argv[], char *en Line 341  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 383  rplinit(int argc, char *argv[], char *en Line 378  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 417  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),                  sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                         SEM_SIGNAUX);                          SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork, getpid(),                  sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                         pthread_self(), SEM_FORK);                          pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 496  rplinit(int argc, char *argv[], char *en Line 491  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),                  sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                         SEM_SIGNAUX);                          SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork, getpid(),                  sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                         pthread_self(), SEM_FORK);                          pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 543  rplinit(int argc, char *argv[], char *en Line 538  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 584  rplinit(int argc, char *argv[], char *en Line 579  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 633  rplinit(int argc, char *argv[], char *en Line 628  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 671  rplinit(int argc, char *argv[], char *en Line 666  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 720  rplinit(int argc, char *argv[], char *en Line 715  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 758  rplinit(int argc, char *argv[], char *en Line 753  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 807  rplinit(int argc, char *argv[], char *en Line 802  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 848  rplinit(int argc, char *argv[], char *en Line 843  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 895  rplinit(int argc, char *argv[], char *en Line 890  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 936  rplinit(int argc, char *argv[], char *en Line 931  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 985  rplinit(int argc, char *argv[], char *en Line 980  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1026  rplinit(int argc, char *argv[], char *en Line 1021  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1075  rplinit(int argc, char *argv[], char *en Line 1070  rplinit(int argc, char *argv[], char *en
             sem_post(semaphore_gestionnaires_signaux);              sem_post(semaphore_gestionnaires_signaux);
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),              sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                     SEM_SIGNAUX);                      SEM_SIGNAUX);
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),              sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                     pthread_self(), SEM_FORK);                      pthread_self(), SEM_FORK);
 #       endif  #       endif
   
Line 1181  rplinit(int argc, char *argv[], char *en Line 1176  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1225  rplinit(int argc, char *argv[], char *en Line 1220  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1276  rplinit(int argc, char *argv[], char *en Line 1271  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 1339  rplinit(int argc, char *argv[], char *en Line 1334  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 1392  rplinit(int argc, char *argv[], char *en Line 1387  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1435  rplinit(int argc, char *argv[], char *en Line 1430  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1480  rplinit(int argc, char *argv[], char *en Line 1475  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1525  rplinit(int argc, char *argv[], char *en Line 1520  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1569  rplinit(int argc, char *argv[], char *en Line 1564  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1614  rplinit(int argc, char *argv[], char *en Line 1609  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1651  rplinit(int argc, char *argv[], char *en Line 1646  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1688  rplinit(int argc, char *argv[], char *en Line 1683  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1734  rplinit(int argc, char *argv[], char *en Line 1729  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1788  rplinit(int argc, char *argv[], char *en Line 1783  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1833  rplinit(int argc, char *argv[], char *en Line 1828  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1870  rplinit(int argc, char *argv[], char *en Line 1865  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1915  rplinit(int argc, char *argv[], char *en Line 1910  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 1960  rplinit(int argc, char *argv[], char *en Line 1955  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2005  rplinit(int argc, char *argv[], char *en Line 2000  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2042  rplinit(int argc, char *argv[], char *en Line 2037  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2094  rplinit(int argc, char *argv[], char *en Line 2089  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2155  rplinit(int argc, char *argv[], char *en Line 2150  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2205  rplinit(int argc, char *argv[], char *en Line 2200  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2245  rplinit(int argc, char *argv[], char *en Line 2240  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2292  rplinit(int argc, char *argv[], char *en Line 2287  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2344  rplinit(int argc, char *argv[], char *en Line 2339  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2405  rplinit(int argc, char *argv[], char *en Line 2400  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork, getpid(),                                              .semaphore_fork, getpid(),
                                             pthread_self(), SEM_FORK);                                              pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 2454  rplinit(int argc, char *argv[], char *en Line 2449  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2529  rplinit(int argc, char *argv[], char *en Line 2524  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                       endif  #                                       endif
   
Line 2576  rplinit(int argc, char *argv[], char *en Line 2571  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2620  rplinit(int argc, char *argv[], char *en Line 2615  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 2749  rplinit(int argc, char *argv[], char *en Line 2744  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2792  rplinit(int argc, char *argv[], char *en Line 2787  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2841  rplinit(int argc, char *argv[], char *en Line 2836  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2885  rplinit(int argc, char *argv[], char *en Line 2880  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2941  rplinit(int argc, char *argv[], char *en Line 2936  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 2995  rplinit(int argc, char *argv[], char *en Line 2990  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3066  rplinit(int argc, char *argv[], char *en Line 3061  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3110  rplinit(int argc, char *argv[], char *en Line 3105  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3153  rplinit(int argc, char *argv[], char *en Line 3148  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3197  rplinit(int argc, char *argv[], char *en Line 3192  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3240  rplinit(int argc, char *argv[], char *en Line 3235  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3305  rplinit(int argc, char *argv[], char *en Line 3300  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux,                  sem_destroy2(semaphore_gestionnaires_signaux,
                         getpid(), SEM_SIGNAUX);                          getpid(), SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork,                  sem_destroy3((*s_etat_processus).semaphore_fork,
                         getpid(), pthread_self(), SEM_FORK);                          getpid(), pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 3365  rplinit(int argc, char *argv[], char *en Line 3360  rplinit(int argc, char *argv[], char *en
                 sem_post(semaphore_gestionnaires_signaux);                  sem_post(semaphore_gestionnaires_signaux);
                 sem_destroy2(semaphore_gestionnaires_signaux,                  sem_destroy2(semaphore_gestionnaires_signaux,
                         getpid(), SEM_SIGNAUX);                          getpid(), SEM_SIGNAUX);
                 sem_destroy3((*s_etat_processus).semphore_fork,                  sem_destroy3((*s_etat_processus).semaphore_fork,
                         getpid(), pthread_self(), SEM_FORK);                          getpid(), pthread_self(), SEM_FORK);
 #           endif  #           endif
   
Line 3632  rplinit(int argc, char *argv[], char *en Line 3627  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3675  rplinit(int argc, char *argv[], char *en Line 3670  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3732  rplinit(int argc, char *argv[], char *en Line 3727  rplinit(int argc, char *argv[], char *en
                     sem_post(semaphore_gestionnaires_signaux);                      sem_post(semaphore_gestionnaires_signaux);
                     sem_destroy2(semaphore_gestionnaires_signaux,                      sem_destroy2(semaphore_gestionnaires_signaux,
                             getpid(), SEM_SIGNAUX);                              getpid(), SEM_SIGNAUX);
                     sem_destroy3((*s_etat_processus).semphore_fork,                      sem_destroy3((*s_etat_processus).semaphore_fork,
                             getpid(), pthread_self(), SEM_FORK);                              getpid(), pthread_self(), SEM_FORK);
 #               endif  #               endif
   
Line 3822  rplinit(int argc, char *argv[], char *en Line 3817  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 3874  rplinit(int argc, char *argv[], char *en Line 3869  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 3954  rplinit(int argc, char *argv[], char *en Line 3949  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4010  rplinit(int argc, char *argv[], char *en Line 4005  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4107  rplinit(int argc, char *argv[], char *en Line 4102  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4166  rplinit(int argc, char *argv[], char *en Line 4161  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4253  rplinit(int argc, char *argv[], char *en Line 4248  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4301  rplinit(int argc, char *argv[], char *en Line 4296  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4350  rplinit(int argc, char *argv[], char *en Line 4345  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4398  rplinit(int argc, char *argv[], char *en Line 4393  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4451  rplinit(int argc, char *argv[], char *en Line 4446  rplinit(int argc, char *argv[], char *en
                             sem_post(semaphore_gestionnaires_signaux);                              sem_post(semaphore_gestionnaires_signaux);
                             sem_destroy2(semaphore_gestionnaires_signaux,                              sem_destroy2(semaphore_gestionnaires_signaux,
                                     getpid(), SEM_SIGNAUX);                                      getpid(), SEM_SIGNAUX);
                             sem_destroy3((*s_etat_processus).semphore_fork,                              sem_destroy3((*s_etat_processus).semaphore_fork,
                                     getpid(), pthread_self(), SEM_FORK);                                      getpid(), pthread_self(), SEM_FORK);
 #                       endif  #                       endif
   
Line 4524  rplinit(int argc, char *argv[], char *en Line 4519  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4594  rplinit(int argc, char *argv[], char *en Line 4589  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4645  rplinit(int argc, char *argv[], char *en Line 4640  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4697  rplinit(int argc, char *argv[], char *en Line 4692  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4761  rplinit(int argc, char *argv[], char *en Line 4756  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4809  rplinit(int argc, char *argv[], char *en Line 4804  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4853  rplinit(int argc, char *argv[], char *en Line 4848  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 4902  rplinit(int argc, char *argv[], char *en Line 4897  rplinit(int argc, char *argv[], char *en
                                 sem_post(semaphore_gestionnaires_signaux);                                  sem_post(semaphore_gestionnaires_signaux);
                                 sem_destroy2(semaphore_gestionnaires_signaux,                                  sem_destroy2(semaphore_gestionnaires_signaux,
                                         getpid(), SEM_SIGNAUX);                                          getpid(), SEM_SIGNAUX);
                                 sem_destroy3((*s_etat_processus).semphore_fork,                                  sem_destroy3((*s_etat_processus).semaphore_fork,
                                         getpid(), pthread_self(), SEM_FORK);                                          getpid(), pthread_self(), SEM_FORK);
 #                           endif  #                           endif
   
Line 4954  rplinit(int argc, char *argv[], char *en Line 4949  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5008  rplinit(int argc, char *argv[], char *en Line 5003  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 5057  rplinit(int argc, char *argv[], char *en Line 5052  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5111  rplinit(int argc, char *argv[], char *en Line 5106  rplinit(int argc, char *argv[], char *en
                                             semaphore_gestionnaires_signaux,                                              semaphore_gestionnaires_signaux,
                                             getpid(), SEM_SIGNAUX);                                              getpid(), SEM_SIGNAUX);
                                     sem_destroy3((*s_etat_processus)                                      sem_destroy3((*s_etat_processus)
                                             .semphore_fork,                                              .semaphore_fork,
                                             getpid(), pthread_self(), SEM_FORK);                                              getpid(), pthread_self(), SEM_FORK);
 #                               endif  #                               endif
   
Line 5608  rplinit(int argc, char *argv[], char *en Line 5603  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Line 5671  rplinit(int argc, char *argv[], char *en Line 5666  rplinit(int argc, char *argv[], char *en
                                                 semaphore_gestionnaires_signaux,                                                  semaphore_gestionnaires_signaux,
                                                 getpid(), SEM_SIGNAUX);                                                  getpid(), SEM_SIGNAUX);
                                         sem_destroy3((*s_etat_processus)                                          sem_destroy3((*s_etat_processus)
                                                 .semphore_fork, getpid(),                                                  .semaphore_fork, getpid(),
                                                 pthread_self(), SEM_FORK);                                                  pthread_self(), SEM_FORK);
 #                                   endif  #                                   endif
   
Removed from v.1.153  
changed lines
  Added in v.1.155

CVSweb interface <joel.bertrand@systella.fr>