rpl/src/rpl.c - diff

Return to rpl.c CVS log

Up to [local] / rpl / src

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

-version 1.41, 2010/08/18 12:56:55
+version 1.155, 2014/04/25 08:18:59
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.0.18
+   RPL/2 (R) version 4.1.18
-   Copyright (C) 1989-2010 Dr. BERTRAND Joël
+   Copyright (C) 1989-2014 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 23
  #define  MAIN_RPL
  #include "rpl-conv.h"
- #ifdef SEMAPHORES_SYSV
- #ifndef OS2
-     unsigned char       *chemin_semaphores_SysV;
- #endif
- #endif
  /*
  ================================================================================
- Line 37
+ Line 31
  */
  int
- rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home)
+ rplinit(int argc, char *argv[], char *envp[],
+         unsigned char ***resultats, char *rpl_home)
  {
  #   include                             "copyright-conv.h"
  #   include                             "licence-conv.h"
+     char                                **arg_exec;
+ #   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+     char                                pile_signaux[SIGSTKSZ];
+ #   endif
+ #   define RPL_PATH_MAX                 1024
+     char                                repertoire_initial[RPL_PATH_MAX];
      file                                *f_source;
      int                                 erreur_historique;
      int                                 option_P;
-     int                                 status;
+     integer8                            i;
      logical1                            core;
      logical1                            debug;
- Line 77  rplinit(int argc, char *argv[], unsigned
+ Line 82  rplinit(int argc, char *argv[], unsigned
      struct_processus                    *s_etat_processus;
-     struct_table_variables_partagees    s_variables_partagees;
+     struct_liste_variables_partagees    *l_element_partage_courant;
+     struct_liste_variables_partagees    *l_element_partage_suivant;
+     struct_liste_variables_statiques    *l_element_statique_courant;
+     struct_liste_variables_statiques    *l_element_statique_suivant;
+     struct_arbre_variables_partagees    *s_arbre_variables_partagees;
+     struct_liste_variables_partagees    *l_liste_variables_partagees;
      struct sigaction                    action;
      struct sigaction                    registre;
- Line 96  rplinit(int argc, char *argv[], unsigned
+ Line 108  rplinit(int argc, char *argv[], unsigned
      unsigned char                       *ptr;
      unsigned char                       *tampon;
-     unsigned long                       i;
      unsigned long                       unite_fichier;
      void                                *l_element_courant;
- Line 106  rplinit(int argc, char *argv[], unsigned
+ Line 117  rplinit(int argc, char *argv[], unsigned
      volatile unsigned char              traitement_fichier_temporaire;
      errno = 0;
+     s_queue_signaux = NULL;
+     routine_recursive = 0;
+     pid_processus_pere = getpid();
  #   ifdef DEBUG_MEMOIRE
      debug_memoire_initialisation();
- Line 115  rplinit(int argc, char *argv[], unsigned
+ Line 129  rplinit(int argc, char *argv[], unsigned
      setvbuf(stderr, NULL, _IOLBF, 0);
  #   ifndef SEMAPHORES_NOMMES
-     sem_init(&semaphore_liste_threads, 0, 1);
      sem_init(&semaphore_gestionnaires_signaux, 0, 0);
-     sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
  #   else
-     semaphore_liste_threads = sem_init2(1, sem_liste_threads);
+     semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);
-     semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
-     semaphore_gestionnaires_signaux_atomique = sem_init2(1,
+     if (semaphore_gestionnaires_signaux == SEM_FAILED)
-             sem_gestionnaires_signaux_atomique);
-     if ((semaphore_liste_threads == SEM_FAILED) ||
-             (semaphore_gestionnaires_signaux == SEM_FAILED) ||
-             (semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
      {
          erreur = d_es_allocation_memoire;
- Line 152  rplinit(int argc, char *argv[], unsigned
+ Line 159  rplinit(int argc, char *argv[], unsigned
      if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
      {
+ #       ifndef SEMAPHORES_NOMMES
+         sem_post(&semaphore_gestionnaires_signaux);
+         sem_destroy(&semaphore_gestionnaires_signaux);
+ #       else
+         sem_post(semaphore_gestionnaires_signaux);
+         sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
+ #       endif
          erreur = d_es_allocation_memoire;
          if ((langue = getenv("LANG")) != NULL)
- Line 183  rplinit(int argc, char *argv[], unsigned
+ Line 198  rplinit(int argc, char *argv[], unsigned
          (*s_etat_processus).langue = 'E';
      }
+     if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
+     {
+ #       ifndef SEMAPHORES_NOMMES
+         sem_post(&semaphore_gestionnaires_signaux);
+         sem_destroy(&semaphore_gestionnaires_signaux);
+ #       else
+         sem_post(semaphore_gestionnaires_signaux);
+         sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
+ #       endif
+         if ((*s_etat_processus).langue == 'F')
+         {
+             uprintf("+++Système : Mémoire insuffisante\n");
+         }
+         else
+         {
+             uprintf("+++System : Not enough memory\n");
+         }
+         return(EXIT_FAILURE);
+     }
+     if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)
+     {
+ #       ifndef SEMAPHORES_NOMMES
+         sem_post(&semaphore_gestionnaires_signaux);
+         sem_destroy(&semaphore_gestionnaires_signaux);
+ #       else
+         sem_post(semaphore_gestionnaires_signaux);
+         sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
+ #       endif
+         if ((*s_etat_processus).langue == 'F')
+         {
+             uprintf("+++Système : Mémoire insuffisante\n");
+         }
+         else
+         {
+             uprintf("+++System : Not enough memory\n");
+         }
+         return(EXIT_FAILURE);
+     }
+     for(i = 0; i < argc; i++)
+     {
+         arg_exec[i] = argv[i];
+     }
+     argv[argc] = NULL;
+     initialisation_contexte_cas(s_etat_processus);
      (*s_etat_processus).exception = d_ep;
      (*s_etat_processus).erreur_systeme = d_es;
      (*s_etat_processus).erreur_execution = d_ex;
+     (*s_etat_processus).requete_redemarrage = d_faux;
      (*s_etat_processus).rpl_home = rpl_home;
-     insertion_thread(s_etat_processus, d_vrai);
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+     pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus),
+             &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
      pthread_mutexattr_init(&attributs_mutex);
      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
-     pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
+     pthread_mutex_init(&((*s_etat_processus).mutex_interruptions),
+             &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+     pthread_mutex_init(&((*s_etat_processus).mutex_signaux),
+             &attributs_mutex);
      pthread_mutexattr_destroy(&attributs_mutex);
      pthread_mutexattr_init(&attributs_mutex);
- Line 202  rplinit(int argc, char *argv[], unsigned
+ Line 282  rplinit(int argc, char *argv[], unsigned
              &attributs_mutex);
      pthread_mutexattr_destroy(&attributs_mutex);
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+     pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+     pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
  #   ifndef SEMAPHORES_NOMMES
-     sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
+         sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
  #   else
-     if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==
+         if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
-             SEM_FAILED)
+                 pthread_self(), SEM_FORK)) == SEM_FAILED)
+         {
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             liberation_contexte_cas(s_etat_processus);
+             if ((*s_etat_processus).langue == 'F')
+             {
+                 uprintf("+++Système : Mémoire insuffisante\n");
+             }
+             else
+             {
+                 uprintf("+++System : Not enough memory\n");
+             }
+             return(EXIT_FAILURE);
+         }
+ #   endif
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+     pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
+             &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
+     (*s_etat_processus).chemin_fichiers_temporaires =
+             recherche_chemin_fichiers_temporaires(s_etat_processus);
+     insertion_thread(s_etat_processus, d_vrai);
+     creation_queue_signaux(s_etat_processus);
+     if ((*s_etat_processus).erreur_systeme != d_es)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
          if ((*s_etat_processus).langue == 'F')
          {
              uprintf("+++Système : Mémoire insuffisante\n");
- Line 219  rplinit(int argc, char *argv[], unsigned
+ Line 358  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   endif
-     pthread_mutexattr_init(&attributs_mutex);
+     if (d_forced_locale == 0)
-     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+     {
-     pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
+         localisation_courante(s_etat_processus);
-             &attributs_mutex);
+     }
-     pthread_mutexattr_destroy(&attributs_mutex);
+     else
+     {
-     (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees;
+         if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
+                 + 1) * sizeof(unsigned char))) == NULL)
-     s_variables_partagees.nombre_variables = 0;
+         {
-     s_variables_partagees.nombre_variables_allouees = 0;
+ #           ifndef SEMAPHORES_NOMMES
-     s_variables_partagees.table = NULL;
+                 sem_post(&((*s_etat_processus).semaphore_fork));
+                 sem_post(&semaphore_gestionnaires_signaux);
-     pthread_mutexattr_init(&attributs_mutex);
+                 sem_destroy(&semaphore_gestionnaires_signaux);
-     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+                 sem_destroy(&((*s_etat_processus).semaphore_fork));
-     pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees))
+ #           else
-             .mutex), &attributs_mutex);
+                 sem_post((*s_etat_processus).semaphore_fork);
-     pthread_mutexattr_destroy(&attributs_mutex);
+                 sem_post(semaphore_gestionnaires_signaux);
+                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                         SEM_SIGNAUX);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
-     (*s_etat_processus).chemin_fichiers_temporaires =
+             liberation_contexte_cas(s_etat_processus);
-             recherche_chemin_fichiers_temporaires(s_etat_processus);
+             liberation_queue_signaux(s_etat_processus);
- #   ifdef SEMAPHORES_SYSV
+             if ((*s_etat_processus).langue == 'F')
- #   ifndef OS2
+             {
-     chemin_semaphores_SysV = (*s_etat_processus).chemin_fichiers_temporaires;
+                 uprintf("+++Système : Mémoire insuffisante\n");
- #   endif
+             }
- #   endif
+             else
+             {
+                 uprintf("+++System : Not enough memory\n");
+             }
- #   ifdef _BROKEN_SIGINFO
+             return(EXIT_FAILURE);
-     creation_fifos_signaux(s_etat_processus);
+         }
- #   ifdef return
+         strcpy((*s_etat_processus).localisation, d_locale);
- #       undef return
+     }
- #   endif
- #   define return destruction_fifos_signaux(s_etat_processus); return
- #   endif
-     localisation_courante(s_etat_processus);
      (*s_etat_processus).erreur_systeme = d_es;
      if ((*s_etat_processus).localisation == NULL)
- Line 265  rplinit(int argc, char *argv[], unsigned
+ Line 407  rplinit(int argc, char *argv[], unsigned
          if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
                  sizeof(unsigned char))) == NULL)
          {
+ #           ifndef SEMAPHORES_NOMMES
+                 sem_post(&((*s_etat_processus).semaphore_fork));
+                 sem_post(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_post(semaphore_gestionnaires_signaux);
+                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                         SEM_SIGNAUX);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             liberation_queue_signaux(s_etat_processus);
              if ((*s_etat_processus).langue == 'F')
              {
                  uprintf("+++Système : Mémoire insuffisante\n");
- Line 280  rplinit(int argc, char *argv[], unsigned
+ Line 439  rplinit(int argc, char *argv[], unsigned
          strcpy((*s_etat_processus).localisation, d_locale);
      }
-     printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
+     if (resultats == NULL) // Appel direct
-             ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);
-     if ((*s_etat_processus).langue == 'F')
-     {
-         printf("+++Copyright (C) 1989 à 2009, 2010 BERTRAND Joël\n");
-     }
-     else
      {
-         printf("+++Copyright (C) 1989 to 2009, 2010 BERTRAND Joel\n");
+         printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
+                 ((*s_etat_processus).langue == 'F')
+                 ? d_date_rpl : d_date_en_rpl);
+         if ((*s_etat_processus).langue == 'F')
+         {
+             printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n");
+         }
+         else
+         {
+             printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");
+         }
      }
      if (getenv("HOME") != NULL)
- Line 314  rplinit(int argc, char *argv[], unsigned
+ Line 477  rplinit(int argc, char *argv[], unsigned
          home = "";
      }
-     // Initialisation d'une clef
+ #   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+         if (stackoverflow_install_handler(interruption_depassement_pile,
+                 pile_signaux, sizeof(pile_signaux)) != 0)
+         {
+ #           ifndef SEMAPHORES_NOMMES
+                 sem_post(&((*s_etat_processus).semaphore_fork));
+                 sem_post(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_post(semaphore_gestionnaires_signaux);
+                 sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                         SEM_SIGNAUX);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             liberation_queue_signaux(s_etat_processus);
-     if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)
+             erreur = d_es_signal;
-     {
-         if ((*s_etat_processus).langue == 'F')
-         {
-             printf("+++Système : Mémoire insuffisante\n");
-         }
-         else
-         {
-             printf("+++System : Not enough memory\n");
-         }
-         return(EXIT_FAILURE);
+             if ((*s_etat_processus).langue == 'F')
-     }
+             {
+                 printf("+++Système : Initialisation de la pile alternative "
+                         "impossible\n");
+             }
+             else
+             {
+                 printf("+++System : Initialization of alternate "
+                         "stack failed\n");
+             }
- #   ifndef SEMAPHORES_NOMMES
+             return(EXIT_FAILURE);
-     if (pthread_setspecific(semaphore_fork_processus_courant,
+         }
-             &((*s_etat_processus).semaphore_fork)) != 0)
  #   else
-     if (pthread_setspecific(semaphore_fork_processus_courant,
-             (*s_etat_processus).semaphore_fork) != 0)
- #   endif
-     {
          if ((*s_etat_processus).langue == 'F')
          {
-             printf("+++Système : Mémoire insuffisante\n");
+             printf("+++Attention : Le système ne supporte pas de pile "
+                     "alternative\n");
          }
          else
          {
-             printf("+++System : Not enough memory\n");
+             printf("+++Warning : Operating system does not support alternate "
+                     "stack\n");
          }
+ #   endif
-         return(EXIT_FAILURE);
+     if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
-     }
-     // Initialisation d'une pile de signal pour récupérer les
-     // débordement de pile
- #   if !defined(Cygwin) && !defined(OpenBSD)
-     if (((*s_etat_processus).pile_signal.ss_sp =
-             malloc((*s_etat_processus).pile_signal.ss_size =
-             SIGSTKSZ)) == NULL)
      {
-         erreur = d_es_allocation_memoire;
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
+         erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
          {
-             printf("+++Système : Mémoire insuffisante\n");
+             printf("+++Système : Initialisation des signaux POSIX "
+                     "impossible\n");
          }
          else
          {
-             printf("+++System : Not enough memory\n");
+             printf("+++System : Initialization of POSIX signals failed\n");
          }
          return(EXIT_FAILURE);
      }
-     (*s_etat_processus).pile_signal.ss_flags = 0;
+     action.sa_handler = interruption1;
+     action.sa_flags = 0;
-     if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 0)
+     if (sigaction(SIGINT, &action, NULL) != 0)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
          {
-             printf("+++Système : Initialisation de la pile spécifique de signal"
+             printf("+++Système : Initialisation des signaux POSIX "
-                     " impossible\n");
+                     "impossible\n");
          }
          else
          {
-             printf("+++System : Initialization of signal stack failed\n");
+             printf("+++System : Initialization of POSIX signals failed\n");
          }
          return(EXIT_FAILURE);
      }
- #   endif
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption1;
+     raise(SIGINT);
- #   else
-     action.sa_handler = interruption1;
- #   endif
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGINT, &action, NULL) != 0)
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+     {
+         nanosleep(&attente, NULL);
+     }
+     if (signal_test != SIGINT)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 416  rplinit(int argc, char *argv[], unsigned
+ Line 654  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     if (sigaction(SIGTERM, &action, NULL) != 0)
-     action.sa_sigaction = interruption2;
- #   else
-     action.sa_handler = interruption2;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGTSTP, &action, NULL) != 0)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
+         erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
          {
              printf("+++Système : Initialisation des signaux POSIX "
- Line 438  rplinit(int argc, char *argv[], unsigned
+ Line 692  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption4;
+     raise(SIGTERM);
- #   else
-     action.sa_handler = interruption4;
+     attente.tv_sec = 0;
- #   endif
+     attente.tv_nsec = 1000000;
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+     {
+         nanosleep(&attente, NULL);
+     }
-     if (sigaction(SIGSTART, &action, NULL) != 0)
+     if (signal_test != SIGTERM)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
+         erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
          {
              printf("+++Système : Initialisation des signaux POSIX "
- Line 460  rplinit(int argc, char *argv[], unsigned
+ Line 741  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     if (sigaction(SIGCONT, &action, NULL) != 0)
+     if (sigaction(SIGALRM, &action, NULL) != 0)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
+         erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
          {
              printf("+++Système : Initialisation des signaux POSIX "
- Line 475  rplinit(int argc, char *argv[], unsigned
+ Line 779  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption5;
+     raise(SIGALRM);
- #   else
-     action.sa_handler = interruption5;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGFSTOP, &action, NULL) != 0)
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
      {
+         nanosleep(&attente, NULL);
+     }
+     if (signal_test != SIGALRM)
+     {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 499  rplinit(int argc, char *argv[], unsigned
+ Line 828  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     action.sa_handler = interruption2;
-     action.sa_sigaction = interruption11;
+     action.sa_flags = 0;
- #   else
-     action.sa_handler = interruption11;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGFABORT, &action, NULL) != 0)
+     if (sigaction(SIGTSTP, &action, NULL) != 0)
      {
-         erreur = d_es_signal;
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          if ((*s_etat_processus).langue == 'F')
          {
- Line 523  rplinit(int argc, char *argv[], unsigned
+ Line 867  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption8;
+     raise(SIGTSTP);
- #   else
-     action.sa_handler = interruption8;
+     attente.tv_sec = 0;
- #   endif
+     attente.tv_nsec = 1000000;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+     {
+         nanosleep(&attente, NULL);
+     }
-     if (sigaction(SIGURG, &action, NULL) != 0)
+     if (signal_test != SIGTSTP)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 547  rplinit(int argc, char *argv[], unsigned
+ Line 916  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     action.sa_handler = interruption5;
-     action.sa_sigaction = interruption7;
+     action.sa_flags = 0;
- #   else
-     action.sa_handler = interruption7;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
      if (sigaction(SIGPIPE, &action, NULL) != 0)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 571  rplinit(int argc, char *argv[], unsigned
+ Line 957  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption6;
+     raise(SIGPIPE);
- #   else
-     action.sa_handler = interruption6;
+     attente.tv_sec = 0;
- #   endif
+     attente.tv_nsec = 1000000;
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+     {
+         nanosleep(&attente, NULL);
+     }
-     if (sigaction(SIGINJECT, &action, NULL) != 0)
+     if (signal_test != SIGPIPE)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 595  rplinit(int argc, char *argv[], unsigned
+ Line 1006  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     action.sa_handler = interruption1;
-     action.sa_sigaction = interruption9;
+     action.sa_flags = 0;
- #   else
-     action.sa_handler = interruption9;
- #   endif
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGABORT, &action, NULL) != 0)
+     if (sigaction(SIGUSR1, &action, NULL) != 0)
      {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 619  rplinit(int argc, char *argv[], unsigned
+ Line 1047  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST;
-     action.sa_sigaction = interruption1;
+     raise(SIGUSR1);
- #   else
-     action.sa_handler = interruption1;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGALRM, &action, NULL) != 0)
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
      {
+         nanosleep(&attente, NULL);
+     }
+     if (signal_test != SIGUSR1)
+     {
+ #       ifndef SEMAPHORES_NOMMES
+             sem_post(&((*s_etat_processus).semaphore_fork));
+             sem_post(&semaphore_gestionnaires_signaux);
+             sem_destroy(&semaphore_gestionnaires_signaux);
+             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_post(semaphore_gestionnaires_signaux);
+             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
+                     SEM_SIGNAUX);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         liberation_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          erreur = d_es_signal;
          if ((*s_etat_processus).langue == 'F')
- Line 643  rplinit(int argc, char *argv[], unsigned
+ Line 1096  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
- #   ifndef _BROKEN_SIGINFO
+     signal_test = SIGTEST + 1;
-     action.sa_sigaction = interruption3;
- #   else
-     action.sa_handler = interruption3;
- #   endif
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
      erreur = d_absence_erreur;
      core = d_faux;
- Line 696  rplinit(int argc, char *argv[], unsigned
+ Line 1144  rplinit(int argc, char *argv[], unsigned
          option_t = d_faux;
          option_v = d_faux;
+         // Lorsque le programme est appelé depuis un shebang, argv[0] contient
+         // le chemin du programme et argv[1] tous les arguments.
+         // argv[2] contient quant à lui le nom du script RPL/2.
+         //
+         // Exemple :
+         // argv[0] : /usr/local/bin/rpl
+         // argv[1] : -csdp -t 800
+         // argv[2] : ./on_exit.rpl
          while((--argc) > 0)
          {
              if ((*(++argv))[0] == '-')
- Line 708  rplinit(int argc, char *argv[], unsigned
+ Line 1165  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_a == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -a présente "
- Line 730  rplinit(int argc, char *argv[], unsigned
+ Line 1209  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_A == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -A présente "
- Line 754  rplinit(int argc, char *argv[], unsigned
+ Line 1255  rplinit(int argc, char *argv[], unsigned
                                  if ((arguments = malloc((strlen(argv[0]) + 7) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 790  rplinit(int argc, char *argv[], unsigned
+ Line 1318  rplinit(int argc, char *argv[], unsigned
                                  if ((arguments = malloc((strlen(argv[0]) + 7) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 821  rplinit(int argc, char *argv[], unsigned
+ Line 1376  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Aucune donnée "
- Line 842  rplinit(int argc, char *argv[], unsigned
+ Line 1419  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_c == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -c présente "
- Line 865  rplinit(int argc, char *argv[], unsigned
+ Line 1464  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_d == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -d présente "
- Line 888  rplinit(int argc, char *argv[], unsigned
+ Line 1509  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_D == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -D présente "
- Line 910  rplinit(int argc, char *argv[], unsigned
+ Line 1553  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_h == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -h présente "
- Line 933  rplinit(int argc, char *argv[], unsigned
+ Line 1598  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_i == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -i présente "
- Line 948  rplinit(int argc, char *argv[], unsigned
+ Line 1635  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_S == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : options -i et -S "
- Line 963  rplinit(int argc, char *argv[], unsigned
+ Line 1672  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_p == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : options -i et -p "
- Line 987  rplinit(int argc, char *argv[], unsigned
+ Line 1718  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_l == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -l présente "
- Line 1019  rplinit(int argc, char *argv[], unsigned
+ Line 1772  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_n == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -n présente "
- Line 1042  rplinit(int argc, char *argv[], unsigned
+ Line 1817  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_p == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -p présente "
- Line 1057  rplinit(int argc, char *argv[], unsigned
+ Line 1854  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_i == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : options -i et -p "
- Line 1080  rplinit(int argc, char *argv[], unsigned
+ Line 1899  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_P > 2)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -P présente "
- Line 1103  rplinit(int argc, char *argv[], unsigned
+ Line 1944  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_s == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -s présente "
- Line 1126  rplinit(int argc, char *argv[], unsigned
+ Line 1989  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_S == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -S présente "
- Line 1141  rplinit(int argc, char *argv[], unsigned
+ Line 2026  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_i == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : options -i et -S "
- Line 1166  rplinit(int argc, char *argv[], unsigned
+ Line 2073  rplinit(int argc, char *argv[], unsigned
                                          malloc((strlen(argv[0]) + 1) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 1200  rplinit(int argc, char *argv[], unsigned
+ Line 2134  rplinit(int argc, char *argv[], unsigned
                                          malloc((strlen(argv[0]) + 1) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 1228  rplinit(int argc, char *argv[], unsigned
+ Line 2189  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Aucun script "
- Line 1246  rplinit(int argc, char *argv[], unsigned
+ Line 2229  rplinit(int argc, char *argv[], unsigned
                                      compactage((*s_etat_processus)
                                      .definitions_chainees)) == NULL)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Système : Mémoire "
- Line 1261  rplinit(int argc, char *argv[], unsigned
+ Line 2266  rplinit(int argc, char *argv[], unsigned
                              }
                              (*s_etat_processus).longueur_definitions_chainees =
-                                     strlen((*s_etat_processus)
+                                     (integer8) strlen((*s_etat_processus)
                                      .definitions_chainees);
                              break;
- Line 1271  rplinit(int argc, char *argv[], unsigned
+ Line 2276  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_t == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -t présente "
- Line 1296  rplinit(int argc, char *argv[], unsigned
+ Line 2323  rplinit(int argc, char *argv[], unsigned
                                  if ((type_debug = malloc((strlen(argv[0]) + 1) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 1330  rplinit(int argc, char *argv[], unsigned
+ Line 2384  rplinit(int argc, char *argv[], unsigned
                                          malloc((strlen(argv[0]) + 1) *
                                          sizeof(unsigned char))) == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                                   endif
                                      if ((*s_etat_processus).langue == 'F')
                                      {
                                          printf("+++Système : Mémoire "
- Line 1357  rplinit(int argc, char *argv[], unsigned
+ Line 2438  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Aucun niveau "
- Line 1400  rplinit(int argc, char *argv[], unsigned
+ Line 2503  rplinit(int argc, char *argv[], unsigned
                                      default:
                                      {
+ #                                       ifndef SEMAPHORES_NOMMES
+                                         sem_post(&((*s_etat_processus)
+                                                 .semaphore_fork));
+                                         sem_post(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                       else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_post(
+                                                 semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy2(
+                                                 semaphore_gestionnaires_signaux,
+                                                 getpid(), SEM_SIGNAUX);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                       endif
+                                         liberation_contexte_cas(
+                                                 s_etat_processus);
+                                         liberation_queue_signaux(
+                                                 s_etat_processus);
+ #                                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                       endif
                                          if ((*s_etat_processus).langue == 'F')
                                          {
                                              printf("+++Erreur : Niveau "
- Line 1423  rplinit(int argc, char *argv[], unsigned
+ Line 2560  rplinit(int argc, char *argv[], unsigned
                              if (sscanf(type_debug, "%llX",
                                      &((*s_etat_processus).type_debug)) != 1)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Niveau "
- Line 1445  rplinit(int argc, char *argv[], unsigned
+ Line 2604  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_v == d_vrai)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : option -v présente "
- Line 1491  rplinit(int argc, char *argv[], unsigned
+ Line 2672  rplinit(int argc, char *argv[], unsigned
                              break;
                          }
+                         case '-':
+                         case ' ':
+                         {
+                             break;
+                         }
                          default :
                          {
                              if ((*s_etat_processus).langue == 'F')
- Line 1535  rplinit(int argc, char *argv[], unsigned
+ Line 2722  rplinit(int argc, char *argv[], unsigned
              }
          }
+         /*
+          * Dans le cas où le programme est appelé avec l'option -d,
+          * on ne récupère par les signaux de violation d'accès. On
+          * tente simplement la récupération des dépassements de pile.
+          */
          if (debug == d_faux)
          {
+ #   ifdef HAVE_SIGSEGV_RECOVERY
+             if (sigsegv_install_handler(interruption_violation_access) != 0)
+             {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+                 erreur = d_es_signal;
+                 if ((*s_etat_processus).langue == 'F')
+                 {
+                     printf("+++Système : Initialisation de la pile alternative "
+                             "impossible\n");
+                 }
+                 else
+                 {
+                     printf("+++System : Initialization of alternate "
+                             "stack failed\n");
+                 }
+                 return(EXIT_FAILURE);
+             }
+ #   else
+             action.sa_handler = interruption3;
+             action.sa_flags = 0;
              if (sigaction(SIGSEGV, &action, NULL) != 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+                 if ((*s_etat_processus).langue == 'F')
+                 {
+                     printf("+++Système : Initialisation des signaux POSIX "
+                             "impossible\n");
+                 }
+                 else
+                 {
+                     printf("+++System : Initialization of POSIX signals "
+                             "failed\n");
+                 }
+                 return(EXIT_FAILURE);
+             }
+             signal_test = SIGTEST;
+             raise(SIGSEGV);
+             attente.tv_sec = 0;
+             attente.tv_nsec = 1000000;
+             for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+             {
+                 nanosleep(&attente, NULL);
+             }
+             if (signal_test != SIGSEGV)
+             {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+                 erreur = d_es_signal;
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Initialisation des signaux POSIX "
- Line 1552  rplinit(int argc, char *argv[], unsigned
+ Line 2862  rplinit(int argc, char *argv[], unsigned
                  return(EXIT_FAILURE);
              }
+ #   endif
+             action.sa_handler = interruption3;
+             action.sa_flags = 0;
              if (sigaction(SIGBUS, &action, NULL) != 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Initialisation des signaux POSIX "
- Line 1568  rplinit(int argc, char *argv[], unsigned
+ Line 2911  rplinit(int argc, char *argv[], unsigned
                  return(EXIT_FAILURE);
              }
+             signal_test = SIGTEST;
+             raise(SIGBUS);
+             attente.tv_sec = 0;
+             attente.tv_nsec = 1000000;
+             for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+             {
+                 nanosleep(&attente, NULL);
+             }
+             if (signal_test != SIGBUS)
+             {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
+                 erreur = d_es_signal;
+                 if ((*s_etat_processus).langue == 'F')
+                 {
+                     printf("+++Système : Initialisation des signaux POSIX "
+                             "impossible\n");
+                 }
+                 else
+                 {
+                     printf("+++System : Initialization of POSIX signals "
+                             "failed\n");
+                 }
+                 return(EXIT_FAILURE);
+             }
          }
          if (option_n == d_vrai)
          {
- #           ifndef _BROKEN_SIGINFO
+             action.sa_handler = interruption4;
-             action.sa_sigaction = interruption10;
+             action.sa_flags = 0;
- #           else
-             action.sa_handler = interruption10;
- #           endif
-             action.sa_flags = SA_ONSTACK | SA_SIGINFO;
              if (sigaction(SIGHUP, &action, NULL) != 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Initialisation des signaux POSIX "
- Line 1623  rplinit(int argc, char *argv[], unsigned
+ Line 3050  rplinit(int argc, char *argv[], unsigned
                      creation_nom_fichier(s_etat_processus, (*s_etat_processus)
                      .chemin_fichiers_temporaires)) == NULL)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Fichier indisponible\n");
- Line 1638  rplinit(int argc, char *argv[], unsigned
+ Line 3094  rplinit(int argc, char *argv[], unsigned
              if ((f_source = fopen(nom_fichier_temporaire, "w"))
                      == NULL)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Fichier introuvable\n");
- Line 1652  rplinit(int argc, char *argv[], unsigned
+ Line 3137  rplinit(int argc, char *argv[], unsigned
              if (fprintf(f_source, "MODE_INTERACTIF\n") < 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Erreur d'écriture dans un fichier\n");
- Line 1667  rplinit(int argc, char *argv[], unsigned
+ Line 3181  rplinit(int argc, char *argv[], unsigned
              if (fprintf(f_source,
                      "<< DO HALT UNTIL FALSE END >>\n") < 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Erreur d'écriture dans un fichier\n");
- Line 1681  rplinit(int argc, char *argv[], unsigned
+ Line 3224  rplinit(int argc, char *argv[], unsigned
              if (fclose(f_source) != 0)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Fichier indisponible\n");
- Line 1718  rplinit(int argc, char *argv[], unsigned
+ Line 3290  rplinit(int argc, char *argv[], unsigned
          if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) &&
                  (option_S == d_faux))
          {
+ #           ifndef SEMAPHORES_NOMMES
+                 sem_post(&((*s_etat_processus).semaphore_fork));
+                 sem_post(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_post(semaphore_gestionnaires_signaux);
+                 sem_destroy2(semaphore_gestionnaires_signaux,
+                         getpid(), SEM_SIGNAUX);
+                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                         getpid(), pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             liberation_queue_signaux(s_etat_processus);
+ #           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                 stackoverflow_deinstall_handler();
+ #           endif
+ #           ifdef HAVE_SIGSEGV_RECOVERY
+                 if (debug == d_faux)
+                 {
+                     sigsegv_deinstall_handler();
+                 }
+ #           endif
              if (presence_definition == 'O')
              {
                  if ((*s_etat_processus).langue == 'F')
- Line 1750  rplinit(int argc, char *argv[], unsigned
+ Line 3350  rplinit(int argc, char *argv[], unsigned
          if ((*s_etat_processus).chemin_fichiers_temporaires == NULL)
          {
+ #           ifndef SEMAPHORES_NOMMES
+                 sem_post(&((*s_etat_processus).semaphore_fork));
+                 sem_post(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&semaphore_gestionnaires_signaux);
+                 sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_post(semaphore_gestionnaires_signaux);
+                 sem_destroy2(semaphore_gestionnaires_signaux,
+                         getpid(), SEM_SIGNAUX);
+                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                         getpid(), pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             liberation_queue_signaux(s_etat_processus);
+ #           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                 stackoverflow_deinstall_handler();
+ #           endif
+ #           ifdef HAVE_SIGSEGV_RECOVERY
+                 if (debug == d_faux)
+                 {
+                     sigsegv_deinstall_handler();
+                 }
+ #           endif
              if ((*s_etat_processus).langue == 'F')
              {
                  printf("+++Système : Chemin des fichiers temporaires nul\n");
- Line 1787  rplinit(int argc, char *argv[], unsigned
+ Line 3415  rplinit(int argc, char *argv[], unsigned
              gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);
              (*s_etat_processus).liste_mutexes = NULL;
+             (*s_etat_processus).sections_critiques = 0;
+             (*s_etat_processus).initialisation_scheduler = d_faux;
              (*s_etat_processus).test_instruction = 'N';
              (*s_etat_processus).nombre_arguments = 0;
              (*s_etat_processus).affichage_arguments = 'N';
              (*s_etat_processus).autorisation_conversion_chaine = 'Y';
              (*s_etat_processus).autorisation_evaluation_nom = 'Y';
-             (*s_etat_processus).autorisation_nom_implicite = 'Y';
+             if (mode_interactif == d_vrai)
+             {
+                 (*s_etat_processus).autorisation_nom_implicite = 'Y';
+             }
+             else
+             {
+                 (*s_etat_processus).autorisation_nom_implicite = 'N';
+             }
              (*s_etat_processus).autorisation_empilement_programme = 'N';
              (*s_etat_processus).requete_arret = 'N';
              (*s_etat_processus).evaluation_forcee = 'N';
+             (*s_etat_processus).recherche_type = 'N';
              (*s_etat_processus).constante_symbolique = 'N';
              (*s_etat_processus).traitement_symbolique = 'N';
- Line 1808  rplinit(int argc, char *argv[], unsigned
+ Line 3448  rplinit(int argc, char *argv[], unsigned
              (*s_etat_processus).l_base_pile = NULL;
              (*s_etat_processus).l_base_pile_last = NULL;
-             (*s_etat_processus).s_liste_variables = NULL;
+             (*s_etat_processus).s_arbre_variables = NULL;
+             (*s_etat_processus).l_liste_variables_par_niveau = NULL;
+             (*s_etat_processus).l_liste_variables_statiques = NULL;
              (*s_etat_processus).gel_liste_variables = d_faux;
-             (*s_etat_processus).nombre_variables = 0;
+             s_arbre_variables_partagees = NULL;
-             (*s_etat_processus).nombre_variables_allouees = 0;
+             l_liste_variables_partagees = NULL;
-             (*s_etat_processus).s_liste_variables_statiques = NULL;
+             (*s_etat_processus).s_arbre_variables_partagees =
-             (*s_etat_processus).nombre_variables_statiques = 0;
+                     &s_arbre_variables_partagees;
-             (*s_etat_processus).nombre_variables_statiques_allouees = 0;
+             (*s_etat_processus).l_liste_variables_partagees =
+                     &l_liste_variables_partagees;
+             (*s_etat_processus).pointeur_variable_courante = NULL;
+             (*s_etat_processus).pointeur_variable_statique_courante = NULL;
+             (*s_etat_processus).pointeur_variable_partagee_courante = NULL;
              (*s_etat_processus).niveau_courant = 0;
              (*s_etat_processus).niveau_initial = 0;
              (*s_etat_processus).creation_variables_statiques = d_faux;
              (*s_etat_processus).creation_variables_partagees = d_faux;
-             (*s_etat_processus).position_variable_courante = 0;
-             (*s_etat_processus).position_variable_statique_courante = 0;
              (*s_etat_processus).s_bibliotheques = NULL;
              (*s_etat_processus).s_instructions_externes = NULL;
- Line 1949  rplinit(int argc, char *argv[], unsigned
+ Line 3593  rplinit(int argc, char *argv[], unsigned
              (*s_etat_processus).arbre_instructions = NULL;
              (*s_etat_processus).tid_processus_pere = pthread_self();
+             (*s_etat_processus).tid = pthread_self();
              (*s_etat_processus).pid_processus_pere = getpid();
              (*s_etat_processus).processus_detache = d_vrai;
              (*s_etat_processus).var_volatile_processus_pere = -1;
+             (*s_etat_processus).var_volatile_processus_racine = -1;
              (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
              (*s_etat_processus).var_volatile_alarme = 0;
              (*s_etat_processus).var_volatile_requete_arret = 0;
- Line 1961  rplinit(int argc, char *argv[], unsigned
+ Line 3607  rplinit(int argc, char *argv[], unsigned
              (*s_etat_processus).var_volatile_recursivite = 0;
              (*s_etat_processus).var_volatile_exception_gsl = 0;
              (*s_etat_processus).arret_depuis_abort = 0;
+             (*s_etat_processus).pointeur_signal_lecture = 0;
+             (*s_etat_processus).pointeur_signal_ecriture = 0;
              initialisation_allocateur(s_etat_processus);
              initialisation_drapeaux(s_etat_processus);
+             initialisation_variables(s_etat_processus);
+             initialisation_instructions(s_etat_processus);
              if ((*s_etat_processus).erreur_systeme != d_es)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  if ((*s_etat_processus).langue == 'F')
                  {
                      printf("+++Système : Mémoire insuffisante\n");
- Line 1982  rplinit(int argc, char *argv[], unsigned
+ Line 3660  rplinit(int argc, char *argv[], unsigned
              if (((*s_etat_processus).instruction_derniere_erreur =
                      malloc(sizeof(unsigned char))) == NULL)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  erreur = d_es_allocation_memoire;
                  if ((*s_etat_processus).langue == 'F')
- Line 2011  rplinit(int argc, char *argv[], unsigned
+ Line 3717  rplinit(int argc, char *argv[], unsigned
              if (((*s_etat_processus).instruction_courante = (unsigned char *)
                      malloc(sizeof(unsigned char))) == NULL)
              {
+ #               ifndef SEMAPHORES_NOMMES
+                     sem_post(&((*s_etat_processus).semaphore_fork));
+                     sem_post(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&semaphore_gestionnaires_signaux);
+                     sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_post(semaphore_gestionnaires_signaux);
+                     sem_destroy2(semaphore_gestionnaires_signaux,
+                             getpid(), SEM_SIGNAUX);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 liberation_queue_signaux(s_etat_processus);
+ #               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                     stackoverflow_deinstall_handler();
+ #               endif
+ #               ifdef HAVE_SIGSEGV_RECOVERY
+                     if (debug == d_faux)
+                     {
+                         sigsegv_deinstall_handler();
+                     }
+ #               endif
                  erreur = d_es_allocation_memoire;
                  if ((*s_etat_processus).langue == 'F')
- Line 2040  rplinit(int argc, char *argv[], unsigned
+ Line 3774  rplinit(int argc, char *argv[], unsigned
                  (*((*s_etat_processus).l_base_pile_systeme))
                          .retour_definition = 'Y';
-                 (*s_etat_processus).indep = (struct_objet *) malloc(
+                 (*s_etat_processus).indep = allocation(s_etat_processus, NON);
-                         sizeof(struct_objet));
+                 (*s_etat_processus).depend = allocation(s_etat_processus, NON);
-                 (*s_etat_processus).depend = (struct_objet *) malloc(
-                         sizeof(struct_objet));
                  (*s_etat_processus).parametres_courbes_de_niveau =
-                         (struct_objet *) malloc(sizeof(struct_objet));
+                         allocation(s_etat_processus, NON);
                  if (((*s_etat_processus).indep != NULL) &&
                          ((*s_etat_processus).depend != NULL) &&
- Line 2075  rplinit(int argc, char *argv[], unsigned
+ Line 3807  rplinit(int argc, char *argv[], unsigned
                              ((*((*s_etat_processus).
                              parametres_courbes_de_niveau)).objet == NULL))
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          erreur = d_es_allocation_memoire;
                          if ((*s_etat_processus).langue == 'F')
- Line 2099  rplinit(int argc, char *argv[], unsigned
+ Line 3859  rplinit(int argc, char *argv[], unsigned
                              (*((*s_etat_processus).depend)).objet)).nom ==
                              NULL))
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          erreur = d_es_allocation_memoire;
                          if ((*s_etat_processus).langue == 'F')
- Line 2151  rplinit(int argc, char *argv[], unsigned
+ Line 3939  rplinit(int argc, char *argv[], unsigned
                              .parametres_courbes_de_niveau)).objet)).donnee
                              == NULL))
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          erreur = d_es_allocation_memoire;
                          if ((*s_etat_processus).langue == 'F')
- Line 2179  rplinit(int argc, char *argv[], unsigned
+ Line 3995  rplinit(int argc, char *argv[], unsigned
                              .objet = malloc(10 * sizeof(unsigned char)))
                              == NULL)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          erreur = d_es_allocation_memoire;
                          if ((*s_etat_processus).langue == 'F')
- Line 2239  rplinit(int argc, char *argv[], unsigned
+ Line 4083  rplinit(int argc, char *argv[], unsigned
                      (*s_etat_processus).my2_lines = d_faux;
                      (*s_etat_processus).mz2_lines = d_faux;
-                     if ((*s_etat_processus).erreur_systeme != d_es)
-                     {
-                         if ((*s_etat_processus).langue == 'F')
-                         {
-                             printf("+++Système : Mémoire insuffisante\n");
-                         }
-                         else
-                         {
-                             printf("+++System : Not enough memory\n");
-                         }
-                         return(EXIT_FAILURE);
-                     }
                      (*s_etat_processus).mode_evaluation_expression = 'N';
                      (*s_etat_processus).mode_execution_programme = 'Y';
- Line 2261  rplinit(int argc, char *argv[], unsigned
+ Line 4091  rplinit(int argc, char *argv[], unsigned
                          if ((erreur = chainage(s_etat_processus)) !=
                                  d_absence_erreur)
                          {
+ #                           ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             liberation_queue_signaux(s_etat_processus);
+ #                           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                           endif
+ #                           ifdef HAVE_SIGSEGV_RECOVERY
+                                 if (debug == d_faux)
+                                 {
+                                     sigsegv_deinstall_handler();
+                                 }
+ #                           endif
                              if ((*s_etat_processus).langue == 'F')
                              {
                                  printf("+++Fatal :"
- Line 2292  rplinit(int argc, char *argv[], unsigned
+ Line 4151  rplinit(int argc, char *argv[], unsigned
                      if ((erreur = compilation(s_etat_processus)) !=
                              d_absence_erreur)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          if (traitement_fichier_temporaire == 'Y')
                          {
                              if (destruction_fichier(nom_fichier_temporaire)
- Line 2349  rplinit(int argc, char *argv[], unsigned
+ Line 4236  rplinit(int argc, char *argv[], unsigned
                      (*s_etat_processus).position_courante = 0;
                      (*s_etat_processus).traitement_cycle_exit = 'N';
-                     if ((*s_etat_processus).nombre_variables == 0)
+                     if ((*s_etat_processus).s_arbre_variables == NULL)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          if ((*s_etat_processus).langue == 'F')
                          {
                              printf("+++Fatal : Aucun point d'entrée\n");
- Line 2371  rplinit(int argc, char *argv[], unsigned
+ Line 4286  rplinit(int argc, char *argv[], unsigned
                      if (recherche_instruction_suivante(s_etat_processus)
                              == d_erreur)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          if ((*s_etat_processus).langue == 'F')
                          {
                              printf("+++Fatal : Aucun point d'entrée\n");
- Line 2392  rplinit(int argc, char *argv[], unsigned
+ Line 4335  rplinit(int argc, char *argv[], unsigned
                              (*s_etat_processus)
                              .instruction_courante) == d_faux)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          if ((*s_etat_processus).langue == 'F')
                          {
                              printf("+++Fatal : Aucun point d'entrée\n");
- Line 2409  rplinit(int argc, char *argv[], unsigned
+ Line 4380  rplinit(int argc, char *argv[], unsigned
                          return(EXIT_FAILURE);
                      }
-                     if ((*s_etat_processus).s_liste_variables
+                     if ((*(*s_etat_processus).pointeur_variable_courante)
-                             [(*s_etat_processus)
+                             .niveau != 0)
-                             .position_variable_courante].niveau != 0)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          if ((*s_etat_processus).langue == 'F')
                          {
                              printf("+++Fatal : Aucun point d'entrée\n");
- Line 2438  rplinit(int argc, char *argv[], unsigned
+ Line 4436  rplinit(int argc, char *argv[], unsigned
                              strlen(ds_fichier_historique) + 2) *
                              sizeof(unsigned char))) == NULL)
                      {
+ #                       ifndef SEMAPHORES_NOMMES
+                             sem_post(&((*s_etat_processus).semaphore_fork));
+                             sem_post(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&semaphore_gestionnaires_signaux);
+                             sem_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_post(semaphore_gestionnaires_signaux);
+                             sem_destroy2(semaphore_gestionnaires_signaux,
+                                     getpid(), SEM_SIGNAUX);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         liberation_queue_signaux(s_etat_processus);
+ #                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                             stackoverflow_deinstall_handler();
+ #                       endif
+ #                       ifdef HAVE_SIGSEGV_RECOVERY
+                             if (debug == d_faux)
+                             {
+                                 sigsegv_deinstall_handler();
+                             }
+ #                       endif
                          erreur = d_es_allocation_memoire;
                          if ((*s_etat_processus).langue == 'F')
- Line 2456  rplinit(int argc, char *argv[], unsigned
+ Line 4482  rplinit(int argc, char *argv[], unsigned
                              home, ds_fichier_historique);
                      using_history();
+                     // Pour pouvoir utiliser le keymap avant le premier
+                     // appel à readline().
+                     rl_initialize();
                      erreur_historique = read_history(
                              (*s_etat_processus).nom_fichier_historique);
- Line 2465  rplinit(int argc, char *argv[], unsigned
+ Line 4496  rplinit(int argc, char *argv[], unsigned
                      {
                          (*s_etat_processus).erreur_systeme = d_es;
                          encart(s_etat_processus,
-                                 (unsigned long) (5 * 1000000));
+                                 (integer8) (5 * 1000000));
                          if ((*s_etat_processus).erreur_systeme != d_es)
                          {
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
                                  erreur = d_es_allocation_memoire;
                                  if ((*s_etat_processus).langue == 'F')
- Line 2497  rplinit(int argc, char *argv[], unsigned
+ Line 4562  rplinit(int argc, char *argv[], unsigned
                      fflush(stdout);
-                     initialisation_instructions(s_etat_processus);
                      if (arguments != NULL)
                      {
                          tampon = (*s_etat_processus).definitions_chainees;
- Line 2510  rplinit(int argc, char *argv[], unsigned
+ Line 4573  rplinit(int argc, char *argv[], unsigned
                          {
                              if ((*s_etat_processus).erreur_systeme != d_es)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
                                  erreur = d_es_allocation_memoire;
                                  if ((*s_etat_processus).langue == 'F')
- Line 2527  rplinit(int argc, char *argv[], unsigned
+ Line 4624  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Erreur de "
- Line 2550  rplinit(int argc, char *argv[], unsigned
+ Line 4681  rplinit(int argc, char *argv[], unsigned
                          if ((*s_etat_processus).erreur_systeme != d_es)
                          {
+ #                           ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             liberation_queue_signaux(s_etat_processus);
+ #                           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                           endif
+ #                           ifdef HAVE_SIGSEGV_RECOVERY
+                                 if (debug == d_faux)
+                                 {
+                                     sigsegv_deinstall_handler();
+                                 }
+ #                           endif
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
- Line 2580  rplinit(int argc, char *argv[], unsigned
+ Line 4740  rplinit(int argc, char *argv[], unsigned
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
                                  erreur = d_es_allocation_memoire;
                                  if ((*s_etat_processus).langue == 'F')
- Line 2599  rplinit(int argc, char *argv[], unsigned
+ Line 4793  rplinit(int argc, char *argv[], unsigned
                              printf("%s [%d]\n", message, (int) getpid());
                              free(message);
+ #                           ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             liberation_queue_signaux(s_etat_processus);
+ #                           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                           endif
+ #                           ifdef HAVE_SIGSEGV_RECOVERY
+                                 if (debug == d_faux)
+                                 {
+                                     sigsegv_deinstall_handler();
+                                 }
+ #                           endif
                              return(EXIT_FAILURE);
                          }
- Line 2609  rplinit(int argc, char *argv[], unsigned
+ Line 4832  rplinit(int argc, char *argv[], unsigned
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
+                                 erreur = d_es_allocation_memoire;
                                  erreur = d_es_allocation_memoire;
                                  if ((*s_etat_processus).langue == 'F')
- Line 2628  rplinit(int argc, char *argv[], unsigned
+ Line 4886  rplinit(int argc, char *argv[], unsigned
                              printf("%s [%d]\n", message, (int) getpid());
                              free(message);
+ #                           ifndef SEMAPHORES_NOMMES
+                                 sem_post(&((*s_etat_processus).semaphore_fork));
+                                 sem_post(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&semaphore_gestionnaires_signaux);
+                                 sem_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_post(semaphore_gestionnaires_signaux);
+                                 sem_destroy2(semaphore_gestionnaires_signaux,
+                                         getpid(), SEM_SIGNAUX);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             liberation_queue_signaux(s_etat_processus);
+ #                           ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                           endif
+ #                           ifdef HAVE_SIGSEGV_RECOVERY
+                                 if (debug == d_faux)
+                                 {
+                                     sigsegv_deinstall_handler();
+                                 }
+ #                           endif
                              return(EXIT_FAILURE);
                          }
+                         empilement_pile_systeme(s_etat_processus);
                          if (evaluation(s_etat_processus, s_objet, 'E')
                                  == d_erreur)
                          {
- Line 2639  rplinit(int argc, char *argv[], unsigned
+ Line 4928  rplinit(int argc, char *argv[], unsigned
                                  if ((message = messages(s_etat_processus))
                                          == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                         sem_post(&((*s_etat_processus)
+                                                 .semaphore_fork));
+                                         sem_post(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_post(
+                                                 semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy2(
+                                                 semaphore_gestionnaires_signaux,
+                                                 getpid(), SEM_SIGNAUX);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                   endif
+ #                                   ifdef HAVE_SIGSEGV_RECOVERY
+                                         if (debug == d_faux)
+                                         {
+                                             sigsegv_deinstall_handler();
+                                         }
+ #                                   endif
                                      erreur = d_es_allocation_memoire;
                                      if ((*s_etat_processus).langue == 'F')
- Line 2659  rplinit(int argc, char *argv[], unsigned
+ Line 4987  rplinit(int argc, char *argv[], unsigned
                                          (int) getpid());
                                  free(message);
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
+                                 erreur = d_es_allocation_memoire;
                                  return(EXIT_FAILURE);
                              }
- Line 2668  rplinit(int argc, char *argv[], unsigned
+ Line 5031  rplinit(int argc, char *argv[], unsigned
                                  if ((message = messages(s_etat_processus))
                                          == NULL)
                                  {
+ #                                   ifndef SEMAPHORES_NOMMES
+                                         sem_post(&((*s_etat_processus)
+                                                 .semaphore_fork));
+                                         sem_post(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_post(
+                                                 semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy2(
+                                                 semaphore_gestionnaires_signaux,
+                                                 getpid(), SEM_SIGNAUX);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                   endif
+ #                                   ifdef HAVE_SIGSEGV_RECOVERY
+                                         if (debug == d_faux)
+                                         {
+                                             sigsegv_deinstall_handler();
+                                         }
+ #                                   endif
                                      erreur = d_es_allocation_memoire;
                                      if ((*s_etat_processus).langue == 'F')
- Line 2688  rplinit(int argc, char *argv[], unsigned
+ Line 5090  rplinit(int argc, char *argv[], unsigned
                                          (int) getpid());
                                  free(message);
+ #                               ifndef SEMAPHORES_NOMMES
+                                     sem_post(&((*s_etat_processus)
+                                             .semaphore_fork));
+                                     sem_post(&semaphore_gestionnaires_signaux);
+                                     sem_destroy(
+                                             &semaphore_gestionnaires_signaux);
+                                     sem_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_post(semaphore_gestionnaires_signaux);
+                                     sem_destroy2(
+                                             semaphore_gestionnaires_signaux,
+                                             getpid(), SEM_SIGNAUX);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 liberation_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                     stackoverflow_deinstall_handler();
+ #                               endif
+ #                               ifdef HAVE_SIGSEGV_RECOVERY
+                                     if (debug == d_faux)
+                                     {
+                                         sigsegv_deinstall_handler();
+                                     }
+ #                               endif
                                  return(EXIT_FAILURE);
                              }
                          }
- Line 2715  rplinit(int argc, char *argv[], unsigned
+ Line 5151  rplinit(int argc, char *argv[], unsigned
                              if (setjmp(contexte_initial) == 0)
                              {
                                  erreur = sequenceur(s_etat_processus);
+                                 if (erreur == d_absence_erreur)
+                                 {
+                                     if (((*s_etat_processus)
+                                             .arret_depuis_abort == 0) &&
+                                             ((*s_etat_processus).at_exit
+                                             != NULL))
+                                     {
+                                         // Permet de traiter ATEXIT
+                                         // même après réception d'un SIGINT.
+                                         (*s_etat_processus)
+                                                 .var_volatile_alarme = 0;
+                                         (*s_etat_processus)
+                                                 .var_volatile_requete_arret = 0;
+                                         if ((*s_etat_processus).profilage ==
+                                                 d_vrai)
+                                         {
+                                             profilage(s_etat_processus,
+                                                     "ATEXIT");
+                                         }
+                                         erreur = evaluation(s_etat_processus,
+                                                 (*s_etat_processus).at_exit,
+                                                 'E');
+                                         if ((*s_etat_processus).profilage ==
+                                                 d_vrai)
+                                         {
+                                             profilage(s_etat_processus, NULL);
+                                         }
+                                         if (((*s_etat_processus)
+                                                 .erreur_execution != d_ex) ||
+                                                 ((*s_etat_processus).exception
+                                                 != d_ep) || ((*s_etat_processus)
+                                                 .erreur_systeme != d_es))
+                                         {
+                                             printf("%s [%d]\n", message =
+                                                     messages(s_etat_processus),
+                                                     (int) getpid());
+                                             free(message);
+                                             if (test_cfsf(s_etat_processus, 51)
+                                                     == d_faux)
+                                             {
+                                                 printf("%s", ds_beep);
+                                             }
+                                             if ((*s_etat_processus).core ==
+                                                     d_vrai)
+                                             {
+                                                 printf("\n");
+                                                 if ((*s_etat_processus).langue
+                                                         == 'F')
+                                                 {
+                                                     printf("+++Information : Gé"
+                                                             "nération du fichie"
+                                                             "r rpl-core "
+                                                             "[%d]\n", (int)
+                                                             getpid());
+                                                 }
+                                                 else
+                                                 {
+                                                     printf("+++Information : Wr"
+                                                             "iting rpl-core fil"
+                                                             "e [%d]\n",
+                                                             (int) getpid());
+                                                 }
+                                                 rplcore(s_etat_processus);
+                                                 if ((*s_etat_processus).langue
+                                                         == 'F')
+                                                 {
+                                                     printf("+++Information : Pr"
+                                                             "ocessus tracé [%d]"
+                                                             "\n",
+                                                             (int) getpid());
+                                                 }
+                                                 else
+                                                 {
+                                                     printf("+++Information : Do"
+                                                             "ne [%d]\n", (int)
+                                                             getpid());
+                                                 }
+                                                 printf("\n");
+                                                 fflush(stdout);
+                                             }
+                                         }
+                                     }
+                                 }
                              }
                          }
                          else
- Line 2722  rplinit(int argc, char *argv[], unsigned
+ Line 5252  rplinit(int argc, char *argv[], unsigned
                              if (setjmp(contexte_initial) == 0)
                              {
                                  erreur = sequenceur_optimise(s_etat_processus);
-                             }
-                         }
-                         if (erreur == d_absence_erreur)
+                                 if (erreur == d_absence_erreur)
-                         {
+                                 {
-                             if (((*s_etat_processus).var_volatile_alarme == 0)
+                                     if (((*s_etat_processus)
-                                     && ((*s_etat_processus).arret_depuis_abort
+                                             .arret_depuis_abort == 0) &&
-                                     == 0) && ((*s_etat_processus).at_exit
+                                             ((*s_etat_processus).at_exit
-                                     != NULL))
+                                             != NULL))
-                             {
+                                     {
-                                 erreur = evaluation(s_etat_processus,
+                                         // Permet de traiter ATEXIT
-                                         (*s_etat_processus).at_exit, 'E');
+                                         // même après réception d'un SIGINT.
+                                         (*s_etat_processus)
+                                                 .var_volatile_alarme = 0;
+                                         (*s_etat_processus)
+                                                 .var_volatile_requete_arret = 0;
+                                         if ((*s_etat_processus).profilage ==
+                                                 d_vrai)
+                                         {
+                                             profilage(s_etat_processus,
+                                                     "ATEXIT");
+                                         }
+                                         erreur = evaluation(s_etat_processus,
+                                                 (*s_etat_processus).at_exit,
+                                                 'E');
+                                         if ((*s_etat_processus).profilage ==
+                                                 d_vrai)
+                                         {
+                                             profilage(s_etat_processus, NULL);
+                                         }
+                                         if (((*s_etat_processus)
+                                                 .erreur_execution != d_ex) ||
+                                                 ((*s_etat_processus).exception
+                                                 != d_ep) || ((*s_etat_processus)
+                                                 .erreur_systeme != d_es))
+                                         {
+                                             printf("%s [%d]\n", message =
+                                                     messages(s_etat_processus),
+                                                     (int) getpid());
+                                             free(message);
+                                             if (test_cfsf(s_etat_processus, 51)
+                                                     == d_faux)
+                                             {
+                                                 printf("%s", ds_beep);
+                                             }
+                                             if ((*s_etat_processus).core ==
+                                                     d_vrai)
+                                             {
+                                                 printf("\n");
+                                                 if ((*s_etat_processus).langue
+                                                         == 'F')
+                                                 {
+                                                     printf("+++Information : Gé"
+                                                             "nération du fichie"
+                                                             "r rpl-core "
+                                                             "[%d]\n", (int)
+                                                             getpid());
+                                                 }
+                                                 else
+                                                 {
+                                                     printf("+++Information : Wr"
+                                                             "iting rpl-core fil"
+                                                             "e [%d]\n",
+                                                             (int) getpid());
+                                                 }
+                                                 rplcore(s_etat_processus);
+                                                 if ((*s_etat_processus).langue
+                                                         == 'F')
+                                                 {
+                                                     printf("+++Information : Pr"
+                                                             "ocessus tracé [%d]"
+                                                             "\n",
+                                                             (int) getpid());
+                                                 }
+                                                 else
+                                                 {
+                                                     printf("+++Information : Do"
+                                                             "ne [%d]\n", (int)
+                                                             getpid());
+                                                 }
+                                                 printf("\n");
+                                                 fflush(stdout);
+                                             }
+                                         }
+                                     }
+                                 }
                              }
                          }
                      }
+                     for(i = 0; i < (*s_etat_processus).sections_critiques; i++)
+                     {
+                         pthread_mutex_unlock(&mutex_sections_critiques);
+                     }
                      liberation(s_etat_processus, (*s_etat_processus).at_exit);
                      liberation(s_etat_processus, (*s_etat_processus).at_poke);
- Line 2749  rplinit(int argc, char *argv[], unsigned
+ Line 5366  rplinit(int argc, char *argv[], unsigned
                      l_element_courant = (*s_etat_processus).liste_mutexes;
                      while(l_element_courant != NULL)
                      {
-                         pthread_mutex_trylock(&((*((struct_mutex *)
-                                 (*(*((struct_liste_chainee *)
-                                 l_element_courant)).donnee).objet)).mutex));
-                         pthread_mutex_unlock(&((*((struct_mutex *)
-                                 (*(*((struct_liste_chainee *)
-                                 l_element_courant)).donnee).objet)).mutex));
-                         pthread_mutex_destroy(&((*((struct_mutex *)
-                                 (*(*((struct_liste_chainee *)
-                                 l_element_courant)).donnee).objet)).mutex));
                          liberation(s_etat_processus,
                                  (*((struct_liste_chainee *)
                                  l_element_courant)).donnee);
- Line 2777  rplinit(int argc, char *argv[], unsigned
+ Line 5384  rplinit(int argc, char *argv[], unsigned
                          pthread_cancel((*s_etat_processus).thread_fusible);
                      }
-                     pthread_mutex_lock(&((*s_etat_processus).mutex));
+                     pthread_mutex_lock(&((*s_etat_processus)
+                             .mutex_pile_processus));
                      l_element_courant = (void *) (*s_etat_processus)
                              .l_base_pile_processus;
- Line 2850  rplinit(int argc, char *argv[], unsigned
+ Line 5458  rplinit(int argc, char *argv[], unsigned
                          {
                              if ((*s_etat_processus).var_volatile_alarme != 0)
                              {
-                                 kill((*(*((struct_processus_fils *)
+                                 envoi_signal_processus(
+                                         (*(*((struct_processus_fils *)
                                          (*(*((struct_liste_chainee *)
                                          l_element_courant)).donnee).objet))
-                                         .thread).pid, SIGURG);
+                                         .thread).pid, rpl_sigurg);
                              }
                              else
                              {
                                  if ((*s_etat_processus).arret_depuis_abort
                                          == -1)
                                  {
-                                     kill((*(*((struct_processus_fils *)
+                                     envoi_signal_processus(
+                                             (*(*((struct_processus_fils *)
                                              (*(*((struct_liste_chainee *)
                                              l_element_courant)).donnee).objet))
-                                             .thread).pid, SIGFABORT);
+                                             .thread).pid, rpl_sigabort);
                                  }
                                  else
                                  {
-                                     kill((*(*((struct_processus_fils *)
+                                     envoi_signal_processus(
+                                             (*(*((struct_processus_fils *)
                                              (*(*((struct_liste_chainee *)
                                              l_element_courant)).donnee).objet))
-                                             .thread).pid, SIGFSTOP);
+                                             .thread).pid, rpl_sigstop);
                                  }
                              }
                          }
- Line 2889  rplinit(int argc, char *argv[], unsigned
+ Line 5500  rplinit(int argc, char *argv[], unsigned
                                  if ((*s_etat_processus).var_volatile_alarme
                                          != 0)
                                  {
-                                     pthread_kill((*(*((struct_processus_fils *)
+                                     envoi_signal_thread(
+                                             (*(*((struct_processus_fils *)
                                              (*(*((struct_liste_chainee *)
                                              l_element_courant)).donnee).objet))
-                                             .thread).tid, SIGURG);
+                                             .thread).tid, rpl_sigurg);
                                  }
                                  else
                                  {
                                      if ((*s_etat_processus).arret_depuis_abort
                                              == -1)
                                      {
-                                         pthread_kill(
+                                         envoi_signal_thread(
                                                  (*(*((struct_processus_fils *)
                                                  (*(*((struct_liste_chainee *)
                                                  l_element_courant)).donnee)
                                                  .objet)).thread).tid,
-                                                 SIGFABORT);
+                                                 rpl_sigabort);
                                      }
                                      else
                                      {
-                                         pthread_kill(
+                                         envoi_signal_thread(
                                                  (*(*((struct_processus_fils *)
                                                  (*(*((struct_liste_chainee *)
                                                  l_element_courant)).donnee)
                                                  .objet)).thread).tid,
-                                                 SIGFSTOP);
+                                                 rpl_sigstop);
                                      }
                                  }
                              }
- Line 2942  rplinit(int argc, char *argv[], unsigned
+ Line 5554  rplinit(int argc, char *argv[], unsigned
                      while((*s_etat_processus).l_base_pile_processus != NULL)
                      {
-                         status = 0;
                          l_element_courant = (void *)
                                  (*s_etat_processus).l_base_pile_processus;
-                         for(i = 0; i < (unsigned long)
+                         for(i = 0; i < (*(*((struct_processus_fils *)
-                                 (*(*((struct_processus_fils *)
                                  (*(*((struct_liste_chainee *)
                                  l_element_courant)).donnee).objet)).thread)
                                  .nombre_objets_dans_pipe; i++)
- Line 2968  rplinit(int argc, char *argv[], unsigned
+ Line 5577  rplinit(int argc, char *argv[], unsigned
                                          .thread).nombre_objets_dans_pipe--;
                                  action.sa_handler = SIG_IGN;
-                                 action.sa_flags = SA_ONSTACK;
+                                 action.sa_flags = 0;
                                  if (sigaction(SIGPIPE, &action, &registre)
                                          != 0)
                                  {
-                                     pthread_mutex_unlock(
+ #                                   ifndef SEMAPHORES_NOMMES
-                                             &((*s_etat_processus).mutex));
+                                         sem_post(&((*s_etat_processus)
+                                                 .semaphore_fork));
+                                         sem_post(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_post(
+                                                 semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy2(
+                                                 semaphore_gestionnaires_signaux,
+                                                 getpid(), SEM_SIGNAUX);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                   endif
+ #                                   ifdef HAVE_SIGSEGV_RECOVERY
+                                         if (debug == d_faux)
+                                         {
+                                             sigsegv_deinstall_handler();
+                                         }
+ #                                   endif
+                                     pthread_mutex_unlock(&((*s_etat_processus)
+                                             .mutex_pile_processus));
                                      return(EXIT_FAILURE);
                                  }
- Line 2997  rplinit(int argc, char *argv[], unsigned
+ Line 5645  rplinit(int argc, char *argv[], unsigned
                                  if (sigaction(SIGPIPE, &registre, NULL)
                                          != 0)
                                  {
-                                     pthread_mutex_unlock(
+ #                                   ifndef SEMAPHORES_NOMMES
-                                             &((*s_etat_processus).mutex));
+                                         sem_post(&((*s_etat_processus)
+                                                 .semaphore_fork));
+                                         sem_post(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(
+                                                 &semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_post(
+                                                 semaphore_gestionnaires_signaux
+                                                 );
+                                         sem_destroy2(
+                                                 semaphore_gestionnaires_signaux,
+                                                 getpid(), SEM_SIGNAUX);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     liberation_queue_signaux(s_etat_processus);
+ #                                   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                   endif
+ #                                   ifdef HAVE_SIGSEGV_RECOVERY
+                                         if (debug == d_faux)
+                                         {
+                                             sigsegv_deinstall_handler();
+                                         }
+ #                                   endif
+                                     pthread_mutex_unlock(&((*s_etat_processus)
+                                             .mutex_pile_processus));
                                      return(EXIT_FAILURE);
                                  }
                              }
                          }
-                         pthread_mutex_unlock(&((*s_etat_processus).mutex));
+                         pthread_mutex_lock(&((*s_etat_processus)
+                                 .mutex_interruptions));
                          if ((*s_etat_processus)
                                  .nombre_interruptions_non_affectees != 0)
- Line 3013  rplinit(int argc, char *argv[], unsigned
+ Line 5701  rplinit(int argc, char *argv[], unsigned
                                      s_etat_processus);
                          }
+                         pthread_mutex_unlock(&((*s_etat_processus)
+                                 .mutex_interruptions));
+                         pthread_mutex_unlock(&((*s_etat_processus)
+                                 .mutex_pile_processus));
                          nanosleep(&attente, NULL);
-                         pthread_mutex_lock(&((*s_etat_processus).mutex));
+                         scrutation_interruptions(s_etat_processus);
+                         pthread_mutex_lock(&((*s_etat_processus)
+                                 .mutex_pile_processus));
                      }
-                     pthread_mutex_unlock(&((*s_etat_processus).mutex));
+                     pthread_mutex_unlock(&((*s_etat_processus)
+                             .mutex_pile_processus));
                      erreur_historique = write_history(
                              (*s_etat_processus).nom_fichier_historique);
- Line 3167  rplinit(int argc, char *argv[], unsigned
+ Line 5862  rplinit(int argc, char *argv[], unsigned
                       * le libérer...
                       */
-                     for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
+                     liberation_arbre_variables_partagees(s_etat_processus,
-                     {
+                             (*(*s_etat_processus).s_arbre_variables_partagees));
-                         liberation(s_etat_processus,
+                     liberation_arbre_variables(s_etat_processus,
-                                 (*s_etat_processus).s_liste_variables[i].objet);
+                             (*s_etat_processus).s_arbre_variables, d_vrai);
-                         free((*s_etat_processus).s_liste_variables[i].nom);
+                     free((*s_etat_processus).pointeurs_caracteres_variables);
-                     }
-                     free((*s_etat_processus).s_liste_variables);
+                     l_element_statique_courant = (*s_etat_processus)
+                             .l_liste_variables_statiques;
-                     for(i = 0; i < (*s_etat_processus)
+                     while(l_element_statique_courant != NULL)
-                             .nombre_variables_statiques; i++)
                      {
-                         liberation(s_etat_processus, (*s_etat_processus)
+                         l_element_statique_suivant =
-                                 .s_liste_variables_statiques[i].objet);
+                             (*l_element_statique_courant).suivant;
-                         free((*s_etat_processus)
+                         free(l_element_statique_courant);
-                                 .s_liste_variables_statiques[i].nom);
+                         l_element_statique_courant = l_element_statique_suivant;
                      }
-                     free((*s_etat_processus).s_liste_variables_statiques);
+                     l_element_partage_courant = (*(*s_etat_processus)
+                             .l_liste_variables_partagees);
-                     for(i = 0; i < (*((*s_etat_processus)
+                     while(l_element_partage_courant != NULL)
-                             .s_liste_variables_partagees)).nombre_variables;
-                             i++)
                      {
-                         liberation(s_etat_processus, (*((*s_etat_processus)
+                         l_element_partage_suivant =
-                                 .s_liste_variables_partagees)).table[i].objet);
+                                 (*l_element_partage_courant).suivant;
-                         free((*((*s_etat_processus)
+                         free(l_element_partage_courant);
-                                 .s_liste_variables_partagees)).table[i].nom);
+                         l_element_partage_courant = l_element_partage_suivant;
                      }
-                     free((struct_variable_partagee *)
-                             (*((*s_etat_processus).s_liste_variables_partagees))
-                             .table);
                      /*
                       * Si resultats est non nul, rplinit a été appelé
                       * depuis rpl() [librpl] et non main().
- Line 3215  rplinit(int argc, char *argv[], unsigned
+ Line 5904  rplinit(int argc, char *argv[], unsigned
                          {
                              free((*resultats));
-                             if (((*resultats) = malloc(((*s_etat_processus)
+                             if (((*resultats) = malloc(((size_t)
-                                     .hauteur_pile_operationnelle + 1)
+                                     ((*s_etat_processus)
+                                     .hauteur_pile_operationnelle + 1))
                                      * sizeof(unsigned char **))) != NULL)
                              {
                                  (*resultats)[(*s_etat_processus)
- Line 3518  rplinit(int argc, char *argv[], unsigned
+ Line 6208  rplinit(int argc, char *argv[], unsigned
          if (traitement_fichier_temporaire == 'Y')
          {
-             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
+             destruction_fichier(nom_fichier_temporaire);
-             {
-                 return(EXIT_FAILURE);
-             }
              free(nom_fichier_temporaire);
          }
- Line 3533  rplinit(int argc, char *argv[], unsigned
+ Line 6219  rplinit(int argc, char *argv[], unsigned
          }
      }
- #   if !defined(Cygwin) && !defined(OpenBSD)
-     (*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;
-     sigaltstack(&((*s_etat_processus).pile_signal), NULL);
-     free((*s_etat_processus).pile_signal.ss_sp);
- #   endif
      closelog();
      pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
-     pthread_mutex_destroy(&((*((*s_etat_processus).s_liste_variables_partagees))
-             .mutex));
      retrait_thread(s_etat_processus);
-     pthread_mutex_destroy(&((*s_etat_processus).mutex));
+     pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
+     pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
+     pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
+     pthread_mutex_destroy(&mutex_sections_critiques);
+     pthread_mutex_destroy(&mutex_liste_variables_partagees);
  #   ifndef SEMAPHORES_NOMMES
      sem_post(&((*s_etat_processus).semaphore_fork));
      sem_destroy(&((*s_etat_processus).semaphore_fork));
  #   else
      sem_post((*s_etat_processus).semaphore_fork);
-     sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
+     sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
+             SEM_FORK);
  #   endif
      free((*s_etat_processus).localisation);
  #   ifndef SEMAPHORES_NOMMES
-     sem_destroy(&semaphore_liste_threads);
- #   else
-     sem_destroy2(semaphore_liste_threads, sem_liste_threads);
- #   endif
- #   ifndef SEMAPHORES_NOMMES
      sem_post(&semaphore_gestionnaires_signaux);
      sem_destroy(&semaphore_gestionnaires_signaux);
-     sem_destroy(&semaphore_gestionnaires_signaux_atomique);
  #   else
      sem_post(semaphore_gestionnaires_signaux);
-     sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
+     sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
-     sem_destroy2(semaphore_gestionnaires_signaux_atomique,
-             sem_gestionnaires_signaux_atomique);
  #   endif
- #   ifdef _BROKEN_SIGINFO
+     destruction_queue_signaux(s_etat_processus);
-     destruction_fifos_signaux(s_etat_processus);
+     liberation_contexte_cas(s_etat_processus);
- #   undef return
- #   endif
      free((*s_etat_processus).chemin_fichiers_temporaires);
+     if ((*s_etat_processus).requete_redemarrage == d_vrai)
+     {
+         chdir(repertoire_initial);
+         execvp(arg_exec[0], &(arg_exec[0]));
+         erreur = d_erreur;
+     }
+     free(arg_exec);
+     arret_thread_signaux(s_etat_processus);
      free(s_etat_processus);
  #   ifdef DEBUG_MEMOIRE
- Line 3589  rplinit(int argc, char *argv[], unsigned
+ Line 6272  rplinit(int argc, char *argv[], unsigned
      analyse_post_mortem();
  #   endif
+ #   ifdef HAVE_STACK_OVERFLOW_RECOVERY
+     stackoverflow_deinstall_handler();
+ #   endif
+ #   ifdef HAVE_SIGSEGV_RECOVERY
+     if (debug == d_faux)
+     {
+         sigsegv_deinstall_handler();
+     }
+ #   endif
      return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);
  }
- Line 3611  informations(struct_processus *s_etat_pr
+ Line 6305  informations(struct_processus *s_etat_pr
          printf("      -l : licence d'utilisation\n");
          printf("      -n : ignorance du signal HUP\n");
          printf("      -p : précompilation du script avant exécution\n");
-         printf("      -P : profilage\n");
+         printf("      -P : profilage (-P ou -PP)\n");
          printf("      -s : empêchement de l'ouverture de l'écran initial\n");
          printf("      -S : exécution du script passé en ligne de commande\n");
          printf("      -t : trace\n");
- Line 3632  informations(struct_processus *s_etat_pr
+ Line 6326  informations(struct_processus *s_etat_pr
          printf("      -l : prints the user licence of the software\n");
          printf("      -n : ignores HUP signal\n");
          printf("      -p : precompiles script\n");
-         printf("      -P : computes profile data\n");
+         printf("      -P : computes profile data (-P or -PP)\n");
          printf("      -s : disables splash screen\n");
          printf("      -S : executes script written in command line\n");
          printf("      -t : enables tracing mode\n");
- Line 3644  informations(struct_processus *s_etat_pr
+ Line 6338  informations(struct_processus *s_etat_pr
      return;
  }
+ logical1
+ controle_integrite(struct_processus *s_etat_processus,
+         unsigned char *executable_candidat, unsigned char *executable)
+ {
+     unsigned char       *md5;
+     unsigned char       *sha1;
+     if (strcmp(executable, "rplpp") == 0)
+     {
+         md5 = rplpp_md5;
+         sha1 = rplpp_sha1;
+     }
+     else if (strcmp(executable, "rplfile") == 0)
+     {
+         md5 = rplfile_md5;
+         sha1 = rplfile_sha1;
+     }
+     else if (strcmp(executable, "rpliconv") == 0)
+     {
+         md5 = rpliconv_md5;
+         sha1 = rpliconv_sha1;
+     }
+     else if (strcmp(executable, "rplawk") == 0)
+     {
+         md5 = rplawk_md5;
+         sha1 = rplawk_sha1;
+     }
+     else if (strcmp(executable, "rplconvert") == 0)
+     {
+         md5 = rplconvert_md5;
+         sha1 = rplconvert_sha1;
+     }
+     else
+     {
+         return(d_faux);
+     }
+     if (controle(s_etat_processus, executable_candidat, "md5", md5) != d_vrai)
+     {
+         return(d_faux);
+     }
+     if (controle(s_etat_processus, executable_candidat, "sha1", sha1) != d_vrai)
+     {
+         return(d_faux);
+     }
+     return(d_vrai);
+ }
+ unsigned char *
+ date_compilation()
+ {
+     unsigned char       *date;
+     if ((date = malloc((strlen(d_date_en_rpl) + 1) * sizeof(unsigned char)))
+             == NULL)
+     {
+         return(NULL);
+     }
+     strcpy(date, d_date_en_rpl);
+     return(date);
+ }
  // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.41
changed lines
	Added in v.1.155