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.14 and 1.195

-version 1.14, 2010/03/27 13:42:35
+version 1.195, 2017/07/04 10:28:08
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.0.13
+   RPL/2 (R) version 4.1.27
-   Copyright (C) 1989-2010 Dr. BERTRAND Joël
+   Copyright (C) 1989-2017 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 21
  #define  MAIN_RPL
- #include "rpl.conv.h"
+ #include "rpl-conv.h"
+ // Bug de gcc à partir de gcc 4.6 (bug 48544)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wclobbered"
  /*
- Line 31
+ Line 35
  */
  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                             "copyright-conv.h"
- #   include                             "licence.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 71  rplinit(int argc, char *argv[], unsigned
+ Line 86  rplinit(int argc, char *argv[], unsigned
      struct_processus                    *s_etat_processus;
-     struct_table_variables_partagees    s_variables_partagees;
+     struct_liste_chainee                *l_bibliotheques;
+     struct_liste_chainee                *l_bibliotheque_courante;
+     struct_liste_chainee                *l_nouvelle_bibliotheque;
+     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 90  rplinit(int argc, char *argv[], unsigned
+ Line 116  rplinit(int argc, char *argv[], unsigned
      unsigned char                       *ptr;
      unsigned char                       *tampon;
-     unsigned long                       i;
      unsigned long                       unite_fichier;
      void                                *l_element_courant;
- Line 99  rplinit(int argc, char *argv[], unsigned
+ Line 124  rplinit(int argc, char *argv[], unsigned
      volatile int                        erreur;
      volatile unsigned char              traitement_fichier_temporaire;
+     errno = 0;
+     s_queue_signaux = NULL;
+     routine_recursive = 0;
+     nombre_thread_surveillance_processus = 0;
+     pid_processus_pere = getpid();
+     affichage_rplso = d_vrai;
+ #   ifdef DEBUG_PROC
+     __proc = 0;
+ #   endif
+ #   ifdef DEBUG_MEMOIRE
+     debug_memoire_initialisation();
+ #   endif
      setvbuf(stdout, NULL, _IOLBF, 0);
      setvbuf(stderr, NULL, _IOLBF, 0);
-     sem_init(&semaphore_liste_threads, 0, 1);
+     if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL)
-     sem_init(&semaphore_gestionnaires_signaux, 0, 0);
+     {
-     sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
+         erreur = d_es_allocation_memoire;
+         if ((langue = getenv("LANG")) != NULL)
+         {
+             if (strncmp(langue, "fr", 2) == 0)
+             {
+                 uprintf("+++Système : Mémoire insuffisante\n");
+             }
+             else
+             {
+                 uprintf("+++System : Not enough memory\n");
+             }
+         }
+         else
+         {
+             uprintf("+++System : Not enough memory\n");
+         }
-     if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
+         return(EXIT_FAILURE);
+     }
+     (*s_etat_processus).erreur_systeme = d_es;
+     initialisation_allocateur_buffer(s_etat_processus);
+     if ((*s_etat_processus).erreur_systeme != d_es)
+     {
+         erreur = d_es_allocation_memoire;
+         if ((langue = getenv("LANG")) != NULL)
+         {
+             if (strncmp(langue, "fr", 2) == 0)
+             {
+                 uprintf("+++Système : Mémoire insuffisante\n");
+             }
+             else
+             {
+                 uprintf("+++System : Not enough memory\n");
+             }
+         }
+         else
+         {
+             uprintf("+++System : Not enough memory\n");
+         }
+         return(EXIT_FAILURE);
+     }
+     if (initialisation_etat_processus_readline() != 0)
      {
          erreur = d_es_allocation_memoire;
+         if ((langue = getenv("LANG")) != NULL)
+         {
+             if (strncmp(langue, "fr", 2) == 0)
+             {
+                 uprintf("+++Système : Mémoire insuffisante\n");
+             }
+             else
+             {
+                 uprintf("+++System : Not enough memory\n");
+             }
+         }
+         else
+         {
+             uprintf("+++System : Not enough memory\n");
+         }
+         return(EXIT_FAILURE);
+     }
+     if ((langue = getenv("LANG")) != NULL)
+     {
+         (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
+                 ? 'F' : 'E';
+     }
+     else
+     {
+         (*s_etat_processus).langue = 'E';
+     }
+     if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
+     {
          if ((*s_etat_processus).langue == 'F')
          {
-             printf("+++Système : Mémoire insuffisante\n");
+             uprintf("+++Système : Mémoire insuffisante\n");
          }
          else
          {
-             printf("+++System : Not enough memory\n");
+             uprintf("+++System : Not enough memory\n");
          }
          return(EXIT_FAILURE);
      }
+     if ((arg_exec = sys_malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)
+     {
+         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];
+     }
+     arg_exec[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_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), &attributs_mutex);
+     pthread_mutex_init(&((*s_etat_processus).mutex_signaux),
+             &attributs_mutex);
      pthread_mutexattr_destroy(&attributs_mutex);
-     sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
+     pthread_mutexattr_init(&attributs_mutex);
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+     pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
+             &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).protection_liste_mutexes),
+     pthread_mutex_init(&((*s_etat_processus).mutex_allocation_buffer),
              &attributs_mutex);
      pthread_mutexattr_destroy(&attributs_mutex);
-     (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees;
+     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);
-     s_variables_partagees.nombre_variables = 0;
+     pthread_mutexattr_init(&attributs_mutex);
-     s_variables_partagees.nombre_variables_allouees = 0;
+     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
-     s_variables_partagees.table = NULL;
+     pthread_mutex_init(&mutex_liste_variables_partagees, &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_threads, &attributs_mutex);
+     pthread_mutexattr_destroy(&attributs_mutex);
+ #   ifndef SEMAPHORES_NOMMES
+         sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
+ #   else
+         if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
+                 pthread_self(), SEM_FORK)) == SEM_FAILED)
+         {
+             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).s_liste_variables_partagees))
+     pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
-             .mutex), &attributs_mutex);
+             &attributs_mutex);
      pthread_mutexattr_destroy(&attributs_mutex);
-     if ((langue = getenv("LANG")) != NULL)
+     (*s_etat_processus).chemin_fichiers_temporaires =
-     {
+             recherche_chemin_fichiers_temporaires(s_etat_processus);
-         (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
-                 ? 'F' : 'E';
-     }
-     else
-     {
-         (*s_etat_processus).langue = 'E';
-     }
-     localisation_courante(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_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             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')
          {
-             printf("+++Système : Mémoire insuffisante\n");
+             uprintf("+++Système : Mémoire insuffisante\n");
          }
          else
          {
-             printf("+++System : Not enough memory\n");
+             uprintf("+++System : Not enough memory\n");
          }
          return(EXIT_FAILURE);
      }
-     printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
+     if (d_forced_locale == 0)
-             ((*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");
+         localisation_courante(s_etat_processus);
      }
      else
      {
-         printf("+++Copyright (C) 1989 to 2009, 2010 BERTRAND Joel\n");
+         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_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             destruction_queue_signaux(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);
+         }
+         strcpy((*s_etat_processus).localisation, d_locale);
+     }
+     (*s_etat_processus).erreur_systeme = d_es;
+     if ((*s_etat_processus).localisation == NULL)
+     {
+         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_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             destruction_queue_signaux(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);
+         }
+         strcpy((*s_etat_processus).localisation, d_locale);
+     }
+     if (resultats == NULL) // Appel direct
+     {
+         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 à 2016, 2017 BERTRAND Joël\n");
+         }
+         else
+         {
+             printf("+++Copyright (C) 1989 to 2016, 2017 BERTRAND Joel\n");
+         }
      }
      if (getenv("HOME") != NULL)
- Line 215  rplinit(int argc, char *argv[], unsigned
+ Line 480  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                         pthread_self(), SEM_FORK);
+ #           endif
-     if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)
+             liberation_contexte_cas(s_etat_processus);
-     {
+             destruction_queue_signaux(s_etat_processus);
-         if ((*s_etat_processus).langue == 'F')
-         {
-             printf("+++Système : Mémoire insuffisante\n");
-         }
-         else
-         {
-             printf("+++System : Not enough memory\n");
-         }
-         return(EXIT_FAILURE);
+             erreur = d_es_signal;
-     }
-     if (pthread_setspecific(semaphore_fork_processus_courant,
+             if ((*s_etat_processus).langue == 'F')
-             &((*s_etat_processus).semaphore_fork)) != 0)
+             {
-     {
+                 printf("+++Système : Initialisation de la pile alternative "
+                         "impossible\n");
+             }
+             else
+             {
+                 printf("+++System : Initialization of alternate "
+                         "stack failed\n");
+             }
+             return(EXIT_FAILURE);
+         }
+ #   else
          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);
+     action.sa_handler = interruption1;
-     }
+     action.sa_flags = 0;
-     // Initialisation d'une pile de signal pour récupérer les
-     // débordement de pile
- #   ifndef Cygwin
+     if (sigaction(SIGINT, &action, NULL) != 0)
-     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_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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;
+     signal_test = SIGTEST;
+     raise(SIGINT);
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+     {
+         nanosleep(&attente, NULL);
+     }
-     if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 0)
+     if (signal_test != SIGINT)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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
-     action.sa_sigaction = interruption1;
+     if (sigaction(SIGTERM, &action, NULL) != 0)
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGINT, &action, NULL) != 0)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 308  rplinit(int argc, char *argv[], unsigned
+ Line 637  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption2;
+     signal_test = SIGTEST;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     raise(SIGTERM);
-     if (sigaction(SIGTSTP, &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 != SIGTERM)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 326  rplinit(int argc, char *argv[], unsigned
+ Line 681  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption4;
+     if (sigaction(SIGUSR2, &action, NULL) != 0)
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
-     if (sigaction(SIGSTART, &action, NULL) != 0)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 344  rplinit(int argc, char *argv[], unsigned
+ Line 714  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     if (sigaction(SIGCONT, &action, NULL) != 0)
+     signal_test = SIGTEST;
+     raise(SIGUSR2);
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
      {
+         nanosleep(&attente, NULL);
+     }
+     if (signal_test != SIGUSR2)
+     {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 359  rplinit(int argc, char *argv[], unsigned
+ Line 758  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption5;
+     action.sa_handler = interruption2;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     action.sa_flags = 0;
-     if (sigaction(SIGFSTOP, &action, NULL) != 0)
+     if (sigaction(SIGTSTP, &action, NULL) != 0)
      {
-         erreur = d_es_signal;
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_queue_signaux(s_etat_processus);
+ #       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+             stackoverflow_deinstall_handler();
+ #       endif
          if ((*s_etat_processus).langue == 'F')
          {
- Line 379  rplinit(int argc, char *argv[], unsigned
+ Line 792  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption8;
+     signal_test = SIGTEST;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     raise(SIGTSTP);
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
+     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_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 399  rplinit(int argc, char *argv[], unsigned
+ Line 836  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption7;
+     action.sa_handler = interruption5;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     action.sa_flags = 0;
      if (sigaction(SIGPIPE, &action, NULL) != 0)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 419  rplinit(int argc, char *argv[], unsigned
+ Line 872  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption6;
+     signal_test = SIGTEST;
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+     raise(SIGPIPE);
-     if (sigaction(SIGINJECT, &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 != SIGPIPE)
+     {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 439  rplinit(int argc, char *argv[], unsigned
+ Line 916  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption9;
+     action.sa_handler = interruption1;
-     action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+     action.sa_flags = 0;
-     if (sigaction(SIGABORT, &action, NULL) != 0)
+     if (sigaction(SIGUSR1, &action, NULL) != 0)
      {
+ #       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_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 459  rplinit(int argc, char *argv[], unsigned
+ Line 952  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption1;
+     signal_test = SIGTEST;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+     raise(SIGUSR1);
+     attente.tv_sec = 0;
+     attente.tv_nsec = 1000000;
-     if (sigaction(SIGALRM, &action, NULL) != 0)
+     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_destroy(&((*s_etat_processus).semaphore_fork));
+ #       else
+             sem_post((*s_etat_processus).semaphore_fork);
+             sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
+                     pthread_self(), SEM_FORK);
+ #       endif
+         liberation_contexte_cas(s_etat_processus);
+         destruction_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 479  rplinit(int argc, char *argv[], unsigned
+ Line 996  rplinit(int argc, char *argv[], unsigned
          return(EXIT_FAILURE);
      }
-     action.sa_sigaction = interruption3;
+     signal_test = SIGTEST + 1;
-     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-     (*s_etat_processus).chemin_fichiers_temporaires =
-             recherche_chemin_fichiers_temporaires(s_etat_processus);
      erreur = d_absence_erreur;
      core = d_faux;
- Line 496  rplinit(int argc, char *argv[], unsigned
+ Line 1009  rplinit(int argc, char *argv[], unsigned
      drapeau_encart = 'Y';
      debug = d_faux;
      arguments = NULL;
+     l_bibliotheques = NULL;
      (*s_etat_processus).s_fichiers = NULL;
      (*s_etat_processus).s_sockets = NULL;
- Line 531  rplinit(int argc, char *argv[], unsigned
+ Line 1045  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 543  rplinit(int argc, char *argv[], unsigned
+ Line 1066  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_a == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 565  rplinit(int argc, char *argv[], unsigned
+ Line 1105  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_A == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 589  rplinit(int argc, char *argv[], unsigned
+ Line 1146  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 625  rplinit(int argc, char *argv[], unsigned
+ Line 1202  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 656  rplinit(int argc, char *argv[], unsigned
+ Line 1253  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 677  rplinit(int argc, char *argv[], unsigned
+ Line 1291  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_c == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 700  rplinit(int argc, char *argv[], unsigned
+ Line 1331  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_d == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 723  rplinit(int argc, char *argv[], unsigned
+ Line 1371  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_D == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 745  rplinit(int argc, char *argv[], unsigned
+ Line 1410  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_h == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 768  rplinit(int argc, char *argv[], unsigned
+ Line 1450  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_i == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 783  rplinit(int argc, char *argv[], unsigned
+ Line 1482  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_S == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 798  rplinit(int argc, char *argv[], unsigned
+ Line 1514  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_p == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 822  rplinit(int argc, char *argv[], unsigned
+ Line 1555  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_l == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 850  rplinit(int argc, char *argv[], unsigned
+ Line 1600  rplinit(int argc, char *argv[], unsigned
                              break;
                          }
+                         case 'm' :
+                         {
+                             while(*(++argv[0]) == ' ');
+                             argv[0]--;
+                             if ((*(++argv[0])) != '\0')
+                             {
+                                 if ((l_nouvelle_bibliotheque = malloc(
+                                         sizeof(struct_liste_chainee))) == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 (*l_nouvelle_bibliotheque).suivant =
+                                         l_bibliotheques;
+                                 if (((*l_nouvelle_bibliotheque).donnee =
+                                         allocation(s_etat_processus, CHN))
+                                         == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 if (((*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet = malloc((strlen(argv[0]) + 1) *
+                                         sizeof(unsigned char))) == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 strcpy((*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet, argv[0]);
+                                 argv[0] += strlen((unsigned char *)
+                                         (*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet) - 1;
+                                 l_bibliotheques = l_nouvelle_bibliotheque;
+                             }
+                             else if ((--argc) > 0)
+                             {
+                                 argv++;
+                                 if ((l_nouvelle_bibliotheque = malloc(
+                                         sizeof(struct_liste_chainee))) == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 (*l_nouvelle_bibliotheque).suivant =
+                                         l_bibliotheques;
+                                 if (((*l_nouvelle_bibliotheque).donnee =
+                                         allocation(s_etat_processus, CHN))
+                                         == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 if (((*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet = malloc((strlen(argv[0]) + 1) *
+                                         sizeof(unsigned char))) == NULL)
+                                 {
+ #                                   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_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 "
+                                                 "insuffisante\n");
+                                     }
+                                     else
+                                     {
+                                         printf("+++System : Not enough "
+                                                 "memory\n");
+                                     }
+                                     return(EXIT_FAILURE);
+                                 }
+                                 strcpy((*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet, argv[0]);
+                                 argv[0] += strlen((unsigned char *)
+                                         (*(*l_nouvelle_bibliotheque).donnee)
+                                         .objet) - 1;
+                                 l_bibliotheques = l_nouvelle_bibliotheque;
+                             }
+                             else
+                             {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
+                                 if ((*s_etat_processus).langue == 'F')
+                                 {
+                                     printf("+++Erreur : Aucune bibliothèque "
+                                             "spécifiée après l'option -A\n");
+                                 }
+                                 else
+                                 {
+                                     printf("+++Error : Library required after "
+                                             "-m option\n");
+                                 }
+                                 return(EXIT_FAILURE);
+                             }
+                             break;
+                         }
                          case 'n' :
                          {
                              if (option_n == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 877  rplinit(int argc, char *argv[], unsigned
+ Line 1939  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_p == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 892  rplinit(int argc, char *argv[], unsigned
+ Line 1971  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_i == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 915  rplinit(int argc, char *argv[], unsigned
+ Line 2011  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_P > 2)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 938  rplinit(int argc, char *argv[], unsigned
+ Line 2051  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_s == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 961  rplinit(int argc, char *argv[], unsigned
+ Line 2091  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_S == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 976  rplinit(int argc, char *argv[], unsigned
+ Line 2123  rplinit(int argc, char *argv[], unsigned
                              }
                              else if (option_i == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1001  rplinit(int argc, char *argv[], unsigned
+ Line 2165  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 1035  rplinit(int argc, char *argv[], unsigned
+ Line 2219  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 1063  rplinit(int argc, char *argv[], unsigned
+ Line 2267  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1078  rplinit(int argc, char *argv[], unsigned
+ Line 2299  rplinit(int argc, char *argv[], unsigned
                              }
                              if (((*s_etat_processus).definitions_chainees =
-                                     compactage((*s_etat_processus)
+                                     compactage(s_etat_processus,
-                                     .definitions_chainees)) == NULL)
+                                     (*s_etat_processus).definitions_chainees))
+                                     == NULL)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1096  rplinit(int argc, char *argv[], unsigned
+ Line 2335  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 1106  rplinit(int argc, char *argv[], unsigned
+ Line 2345  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_t == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1131  rplinit(int argc, char *argv[], unsigned
+ Line 2387  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 1165  rplinit(int argc, char *argv[], unsigned
+ Line 2441  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                                   else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork, getpid(),
+                                             pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 1192  rplinit(int argc, char *argv[], unsigned
+ Line 2488  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1235  rplinit(int argc, char *argv[], unsigned
+ Line 2548  rplinit(int argc, char *argv[], unsigned
                                      default:
                                      {
+ #                                       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_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                       endif
+                                         liberation_contexte_cas(
+                                                 s_etat_processus);
+                                         destruction_queue_signaux(
+                                                 s_etat_processus);
+ #                                       ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                         stackoverflow_deinstall_handler();
+ #                                       endif
                                          if ((*s_etat_processus).langue == 'F')
                                          {
                                              printf("+++Erreur : Niveau "
- Line 1258  rplinit(int argc, char *argv[], unsigned
+ Line 2593  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_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                               else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_queue_signaux(s_etat_processus);
+ #                               ifdef HAVE_STACK_OVERFLOW_RECOVERY
+                                 stackoverflow_deinstall_handler();
+ #                               endif
                                  if ((*s_etat_processus).langue == 'F')
                                  {
                                      printf("+++Erreur : Niveau "
- Line 1272  rplinit(int argc, char *argv[], unsigned
+ Line 2624  rplinit(int argc, char *argv[], unsigned
                                  return(EXIT_FAILURE);
                              }
+                             free(type_debug);
                              break;
                          }
- Line 1279  rplinit(int argc, char *argv[], unsigned
+ Line 2632  rplinit(int argc, char *argv[], unsigned
                          {
                              if (option_v == d_vrai)
                              {
+ #                               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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 1325  rplinit(int argc, char *argv[], unsigned
+ Line 2695  rplinit(int argc, char *argv[], unsigned
                              break;
                          }
+                         case '-':
+                         case ' ':
+                         {
+                             break;
+                         }
                          default :
                          {
                              if ((*s_etat_processus).langue == 'F')
- Line 1369  rplinit(int argc, char *argv[], unsigned
+ Line 2745  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 "
- Line 1387  rplinit(int argc, char *argv[], unsigned
+ Line 2825  rplinit(int argc, char *argv[], unsigned
                  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 "
+                             "impossible\n");
+                 }
+                 else
+                 {
+                     printf("+++System : Initialization of POSIX signals "
+                             "failed\n");
+                 }
+                 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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 "
+                             "impossible\n");
+                 }
+                 else
+                 {
+                     printf("+++System : Initialization of POSIX signals "
+                             "failed\n");
+                 }
+                 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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 "
- Line 1402  rplinit(int argc, char *argv[], unsigned
+ Line 2967  rplinit(int argc, char *argv[], unsigned
                  return(EXIT_FAILURE);
              }
          }
          if (option_n == d_vrai)
          {
-             action.sa_sigaction = interruption10;
+             action.sa_handler = interruption4;
-             action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+             action.sa_flags = 0;
              if (sigaction(SIGHUP, &action, NULL) != 0)
              {
+ #               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_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1453  rplinit(int argc, char *argv[], unsigned
+ Line 3043  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1468  rplinit(int argc, char *argv[], unsigned
+ Line 3082  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1482  rplinit(int argc, char *argv[], unsigned
+ Line 3120  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1497  rplinit(int argc, char *argv[], unsigned
+ Line 3159  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_destroy(&((*s_etat_processus)
+                             .semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1511  rplinit(int argc, char *argv[], unsigned
+ Line 3197  rplinit(int argc, char *argv[], unsigned
              if (fclose(f_source) != 0)
              {
+ #               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_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1548  rplinit(int argc, char *argv[], unsigned
+ Line 3258  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                         getpid(), pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             destruction_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 1580  rplinit(int argc, char *argv[], unsigned
+ Line 3313  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #           else
+                 sem_post((*s_etat_processus).semaphore_fork);
+                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                         getpid(), pthread_self(), SEM_FORK);
+ #           endif
+             liberation_contexte_cas(s_etat_processus);
+             destruction_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 1617  rplinit(int argc, char *argv[], unsigned
+ Line 3373  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';
+             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 1637  rplinit(int argc, char *argv[], unsigned
+ Line 3406  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 1770  rplinit(int argc, char *argv[], unsigned
+ Line 3543  rplinit(int argc, char *argv[], unsigned
                  (*s_etat_processus).pile_origine_interruptions[i] = NULL;
              }
+             (*s_etat_processus).at_exit = NULL;
+             (*s_etat_processus).at_poke = NULL;
+             (*s_etat_processus).traitement_at_poke = 'N';
              (*s_etat_processus).pointeurs_caracteres = NULL;
              (*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 1785  rplinit(int argc, char *argv[], unsigned
+ Line 3564  rplinit(int argc, char *argv[], unsigned
              (*s_etat_processus).var_volatile_traitement_sigint = 0;
              (*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_destroy(&((*s_etat_processus).semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1804  rplinit(int argc, char *argv[], unsigned
+ Line 3611  rplinit(int argc, char *argv[], unsigned
              }
              if (((*s_etat_processus).instruction_derniere_erreur =
-                     malloc(2 * sizeof(unsigned char))) == NULL)
+                     malloc(sizeof(unsigned char))) == NULL)
              {
+ #               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_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1835  rplinit(int argc, char *argv[], unsigned
+ Line 3665  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #               else
+                     sem_post((*s_etat_processus).semaphore_fork);
+                     sem_destroy3((*s_etat_processus).semaphore_fork,
+                             getpid(), pthread_self(), SEM_FORK);
+ #               endif
+                 liberation_contexte_cas(s_etat_processus);
+                 destruction_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 1855  rplinit(int argc, char *argv[], unsigned
+ Line 3708  rplinit(int argc, char *argv[], unsigned
              free((*s_etat_processus).instruction_courante);
-             if ((*s_etat_processus).erreur_systeme == d_es_allocation_memoire)
+             if ((*s_etat_processus).erreur_systeme != d_es)
              {
                  erreur = d_es_allocation_memoire;
              }
- Line 1864  rplinit(int argc, char *argv[], unsigned
+ Line 3717  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 1899  rplinit(int argc, char *argv[], unsigned
+ Line 3750  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 1923  rplinit(int argc, char *argv[], unsigned
+ Line 3797  rplinit(int argc, char *argv[], unsigned
                              (*((*s_etat_processus).depend)).objet)).nom ==
                              NULL))
                      {
+ #                       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_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 1975  rplinit(int argc, char *argv[], unsigned
+ Line 3872  rplinit(int argc, char *argv[], unsigned
                              .parametres_courbes_de_niveau)).objet)).donnee
                              == NULL))
                      {
+ #                       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_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2003  rplinit(int argc, char *argv[], unsigned
+ Line 3923  rplinit(int argc, char *argv[], unsigned
                              .objet = malloc(10 * sizeof(unsigned char)))
                              == NULL)
                      {
+ #                       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_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2063  rplinit(int argc, char *argv[], unsigned
+ Line 4006  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 2085  rplinit(int argc, char *argv[], unsigned
+ Line 4014  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_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 2113  rplinit(int argc, char *argv[], unsigned
+ Line 4066  rplinit(int argc, char *argv[], unsigned
                          }
                      }
+                     /*
+                      * Chargement des bibliothèques pour gérer des
+                      * types externes lors des l'analyse syntaxique et
+                      * compilation.
+                      */
+                     l_bibliotheque_courante = l_bibliotheques;
+                     while(l_bibliotheque_courante != NULL)
+                     {
+                         if (empilement(s_etat_processus, &((*s_etat_processus)
+                                 .l_base_pile), (*l_bibliotheque_courante)
+                                 .donnee) == d_erreur)
+                         {
+ #                           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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 :"
+                                         " Chargement de la bibliothèse %s"
+                                         " impossible\n", (unsigned char *)
+                                         (*(*l_bibliotheque_courante).donnee)
+                                         .objet);
+                             }
+                             else
+                             {
+                                 printf("+++Fatal : Cannot load library %s\n",
+                                         (*(*l_bibliotheque_courante).donnee)
+                                         .objet);
+                             }
+                             if (traitement_fichier_temporaire == 'Y')
+                             {
+                                 if (destruction_fichier(
+                                         nom_fichier_temporaire)
+                                         == d_erreur)
+                                 {
+                                     return(EXIT_FAILURE);
+                                 }
+                                 free(nom_fichier_temporaire);
+                             }
+                             return(EXIT_FAILURE);
+                         }
+                         affichage_rplso = d_faux;
+                         instruction_use(s_etat_processus);
+                         affichage_rplso = d_vrai;
+                         if (depilement(s_etat_processus, &((*s_etat_processus)
+                                 .l_base_pile), &((*l_bibliotheque_courante)
+                                 .donnee)) == d_erreur)
+                         {
+ #                           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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 :"
+                                         " Chargement de la bibliothèse %s"
+                                         " impossible\n", (unsigned char *)
+                                         (*(*l_bibliotheque_courante).donnee)
+                                         .objet);
+                             }
+                             else
+                             {
+                                 printf("+++Fatal : Cannot load library %s\n",
+                                         (*(*l_bibliotheque_courante).donnee)
+                                         .objet);
+                             }
+                             if (traitement_fichier_temporaire == 'Y')
+                             {
+                                 if (destruction_fichier(
+                                         nom_fichier_temporaire)
+                                         == d_erreur)
+                                 {
+                                     return(EXIT_FAILURE);
+                                 }
+                                 free(nom_fichier_temporaire);
+                             }
+                             return(EXIT_FAILURE);
+                         }
+                         l_bibliotheque_courante =
+                                 (*l_bibliotheque_courante).suivant;
+                     }
                      if ((erreur = compilation(s_etat_processus)) !=
                              d_absence_erreur)
                      {
+ #                       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_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2173  rplinit(int argc, char *argv[], unsigned
+ Line 4283  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2195  rplinit(int argc, char *argv[], unsigned
+ Line 4328  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2216  rplinit(int argc, char *argv[], unsigned
+ Line 4372  rplinit(int argc, char *argv[], unsigned
                              (*s_etat_processus)
                              .instruction_courante) == d_faux)
                      {
+ #                       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_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2233  rplinit(int argc, char *argv[], unsigned
+ Line 4412  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2262  rplinit(int argc, char *argv[], unsigned
+ Line 4463  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_destroy(&((*s_etat_processus).semaphore_fork));
+ #                       else
+                             sem_post((*s_etat_processus).semaphore_fork);
+                             sem_destroy3((*s_etat_processus).semaphore_fork,
+                                     getpid(), pthread_self(), SEM_FORK);
+ #                       endif
+                         liberation_contexte_cas(s_etat_processus);
+                         destruction_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 2280  rplinit(int argc, char *argv[], unsigned
+ Line 4504  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 2289  rplinit(int argc, char *argv[], unsigned
+ Line 4518  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2321  rplinit(int argc, char *argv[], unsigned
+ Line 4577  rplinit(int argc, char *argv[], unsigned
                      fflush(stdout);
-                     initialisation_instructions(s_etat_processus);
                      if (arguments != NULL)
                      {
                          tampon = (*s_etat_processus).definitions_chainees;
- Line 2334  rplinit(int argc, char *argv[], unsigned
+ Line 4588  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_destroy(&((*s_etat_processus)
+                                             .semaphore_fork));
+ #                               else
+                                     sem_post((*s_etat_processus)
+                                             .semaphore_fork);
+                                     sem_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2351  rplinit(int argc, char *argv[], unsigned
+ Line 4632  rplinit(int argc, char *argv[], unsigned
                              }
                              else
                              {
+ #                               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_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2370  rplinit(int argc, char *argv[], unsigned
+ Line 4678  rplinit(int argc, char *argv[], unsigned
                          (*s_etat_processus).definitions_chainees = tampon;
                          (*s_etat_processus).position_courante = 0;
+                         (*s_etat_processus).type_en_cours = NON;
                          recherche_type(s_etat_processus);
                          if ((*s_etat_processus).erreur_systeme != d_es)
                          {
+ #                           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_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 2404  rplinit(int argc, char *argv[], unsigned
+ Line 4737  rplinit(int argc, char *argv[], unsigned
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
+ #                               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_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2423  rplinit(int argc, char *argv[], unsigned
+ Line 4783  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_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 2433  rplinit(int argc, char *argv[], unsigned
+ Line 4817  rplinit(int argc, char *argv[], unsigned
                              if ((message = messages(s_etat_processus))
                                      == NULL)
                              {
+ #                               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_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2452  rplinit(int argc, char *argv[], unsigned
+ Line 4864  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_destroy(&((*s_etat_processus)
+                                         .semaphore_fork));
+ #                           else
+                                 sem_post((*s_etat_processus).semaphore_fork);
+                                 sem_destroy3((*s_etat_processus).semaphore_fork,
+                                         getpid(), pthread_self(), SEM_FORK);
+ #                           endif
+                             liberation_contexte_cas(s_etat_processus);
+                             destruction_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 2463  rplinit(int argc, char *argv[], unsigned
+ Line 4901  rplinit(int argc, char *argv[], unsigned
                                  if ((message = messages(s_etat_processus))
                                          == NULL)
                                  {
+ #                                   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_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 2483  rplinit(int argc, char *argv[], unsigned
+ Line 4948  rplinit(int argc, char *argv[], unsigned
                                          (int) getpid());
                                  free(message);
+ #                               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_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2492  rplinit(int argc, char *argv[], unsigned
+ Line 4985  rplinit(int argc, char *argv[], unsigned
                                  if ((message = messages(s_etat_processus))
                                          == NULL)
                                  {
+ #                                   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_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 2512  rplinit(int argc, char *argv[], unsigned
+ Line 5032  rplinit(int argc, char *argv[], unsigned
                                          (int) getpid());
                                  free(message);
+ #                               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_destroy3((*s_etat_processus)
+                                             .semaphore_fork,
+                                             getpid(), pthread_self(), SEM_FORK);
+ #                               endif
+                                 liberation_contexte_cas(s_etat_processus);
+                                 destruction_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 2538  rplinit(int argc, char *argv[], unsigned
+ Line 5085  rplinit(int argc, char *argv[], unsigned
                          {
                              if (setjmp(contexte_initial) == 0)
                              {
+                                 // Libération des bibliothèques
+                                 l_bibliotheque_courante = l_bibliotheques;
+                                 while(l_bibliotheque_courante != NULL)
+                                 {
+                                     if (empilement(s_etat_processus,
+                                             &((*s_etat_processus).l_base_pile),
+                                             (*l_bibliotheque_courante).donnee)
+                                             == d_erreur)
+                                     {
+ #                                       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_destroy3((*s_etat_processus)
+                                                     .semaphore_fork, getpid(),
+                                                     pthread_self(), SEM_FORK);
+ #                                       endif
+                                         liberation_contexte_cas(
+                                                 s_etat_processus);
+                                         destruction_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')
+                                         {
+                                             printf("+++Système : Mémoire "
+                                                     "insuffisante\n");
+                                         }
+                                         else
+                                         {
+                                             printf("+++System : Not enough "
+                                                     "memory\n");
+                                         }
+                                         return(EXIT_FAILURE);
+                                     }
+                                     affichage_rplso = d_faux;
+                                     instruction_remove(s_etat_processus);
+                                     affichage_rplso = d_vrai;
+                                     l_nouvelle_bibliotheque =
+                                             (*l_bibliotheque_courante).suivant;
+                                     free(l_bibliotheque_courante);
+                                     l_bibliotheque_courante =
+                                             l_nouvelle_bibliotheque;
+                                 }
                                  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
                          {
                              if (setjmp(contexte_initial) == 0)
                              {
-                                 erreur = sequenceur_optimise(s_etat_processus);
+                                 erreur = sequenceur_optimise(s_etat_processus,
+                                         l_bibliotheques);
+                                 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);
+                                             }
+                                         }
+                                     }
+                                 }
                              }
                          }
                      }
+                     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);
                      if ((*s_etat_processus).generateur_aleatoire != NULL)
                      {
                          liberation_generateur_aleatoire(s_etat_processus);
- Line 2558  rplinit(int argc, char *argv[], unsigned
+ Line 5369  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 2586  rplinit(int argc, char *argv[], unsigned
+ Line 5387  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 2659  rplinit(int argc, char *argv[], unsigned
+ Line 5461  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, d_faux);
                              }
                              else
                              {
-                                 kill((*(*((struct_processus_fils *)
+                                 if ((*s_etat_processus).arret_depuis_abort
-                                         (*(*((struct_liste_chainee *)
+                                         == -1)
-                                         l_element_courant)).donnee).objet))
+                                 {
-                                         .thread).pid, SIGFSTOP);
+                                     envoi_signal_processus(
+                                             (*(*((struct_processus_fils *)
+                                             (*(*((struct_liste_chainee *)
+                                             l_element_courant)).donnee).objet))
+                                             .thread).pid, rpl_sigabort, d_faux);
+                                 }
+                                 else
+                                 {
+                                     envoi_signal_processus(
+                                             (*(*((struct_processus_fils *)
+                                             (*(*((struct_liste_chainee *)
+                                             l_element_courant)).donnee).objet))
+                                             .thread).pid, rpl_sigstop, d_faux);
+                                 }
                              }
                          }
                          else
- Line 2687  rplinit(int argc, char *argv[], unsigned
+ Line 5503  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
                                  {
-                                     pthread_kill((*(*((struct_processus_fils *)
+                                     if ((*s_etat_processus).arret_depuis_abort
-                                             (*(*((struct_liste_chainee *)
+                                             == -1)
-                                             l_element_courant)).donnee).objet))
+                                     {
-                                             .thread).tid, SIGFSTOP);
+                                         envoi_signal_thread(
+                                                 (*(*((struct_processus_fils *)
+                                                 (*(*((struct_liste_chainee *)
+                                                 l_element_courant)).donnee)
+                                                 .objet)).thread).tid,
+                                                 rpl_sigabort);
+                                     }
+                                     else
+                                     {
+                                         envoi_signal_thread(
+                                                 (*(*((struct_processus_fils *)
+                                                 (*(*((struct_liste_chainee *)
+                                                 l_element_courant)).donnee)
+                                                 .objet)).thread).tid,
+                                                 rpl_sigstop);
+                                     }
                                  }
                              }
- Line 2725  rplinit(int argc, char *argv[], unsigned
+ Line 5557  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;
-                         if ((*s_etat_processus)
+                         for(i = 0; i < (*(*((struct_processus_fils *)
-                                 .nombre_interruptions_non_affectees != 0)
-                         {
-                             affectation_interruptions_logicielles(
-                                     s_etat_processus);
-                         }
-                         for(i = 0; i < (unsigned long)
-                                 (*(*((struct_processus_fils *)
                                  (*(*((struct_liste_chainee *)
                                  l_element_courant)).donnee).objet)).thread)
                                  .nombre_objets_dans_pipe; i++)
- Line 2758  rplinit(int argc, char *argv[], unsigned
+ Line 5580  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_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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 2787  rplinit(int argc, char *argv[], unsigned
+ Line 5636  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_destroy(&((*s_etat_processus)
+                                                 .semaphore_fork));
+ #                                   else
+                                         sem_post((*s_etat_processus)
+                                                 .semaphore_fork);
+                                         sem_destroy3((*s_etat_processus)
+                                                 .semaphore_fork, getpid(),
+                                                 pthread_self(), SEM_FORK);
+ #                                   endif
+                                     liberation_contexte_cas(s_etat_processus);
+                                     destruction_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)
+                         {
+                             affectation_interruptions_logicielles(
+                                     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 2949  rplinit(int argc, char *argv[], unsigned
+ Line 5841  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 2995  rplinit(int argc, char *argv[], unsigned
+ Line 5881  rplinit(int argc, char *argv[], unsigned
                      {
                          if ((*resultats) != NULL)
                          {
-                             free((*resultats));
+                             sys_free((*resultats));
-                             if (((*resultats) = malloc(((*s_etat_processus)
+                             if (((*resultats) = sys_malloc(((size_t)
-                                     .hauteur_pile_operationnelle + 1)
+                                     ((*s_etat_processus)
+                                     .hauteur_pile_operationnelle + 1))
                                      * sizeof(unsigned char **))) != NULL)
                              {
                                  (*resultats)[(*s_etat_processus)
- Line 3264  rplinit(int argc, char *argv[], unsigned
+ Line 6151  rplinit(int argc, char *argv[], unsigned
                          l_element_courant = l_element_suivant;
                      }
-                     free((*s_etat_processus).chemin_fichiers_temporaires);
                      l_element_courant = (*s_etat_processus).s_marques;
                      while(l_element_courant != NULL)
                      {
- Line 3302  rplinit(int argc, char *argv[], unsigned
+ Line 6187  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 3317  rplinit(int argc, char *argv[], unsigned
+ Line 6198  rplinit(int argc, char *argv[], unsigned
          }
      }
- #   ifndef Cygwin
-     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));
+     attente.tv_sec = 0;
+     attente.tv_nsec = GRANULARITE_us * 1000;
+     while(nombre_thread_surveillance_processus != 0)
+     {
+         nanosleep(&attente, NULL);
+         INCR_GRANULARITE(attente.tv_nsec);
+     }
+     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_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
+             SEM_FORK);
+ #   endif
      free((*s_etat_processus).localisation);
-     free(s_etat_processus);
-     sem_destroy(&semaphore_liste_threads);
+     destruction_queue_signaux(s_etat_processus);
-     sem_post(&semaphore_gestionnaires_signaux);
+     liberation_contexte_cas(s_etat_processus);
-     sem_destroy(&semaphore_gestionnaires_signaux);
-     sem_destroy(&semaphore_gestionnaires_signaux_atomique);
+     free((*s_etat_processus).chemin_fichiers_temporaires);
+     if ((*s_etat_processus).requete_redemarrage == d_vrai)
+     {
+         if (chdir(repertoire_initial) == 0)
+         {
+             execvp(arg_exec[0], &(arg_exec[0]));
+         }
+         erreur = d_erreur;
+     }
+     liberation_etat_processus_readline();
+     liberation_allocateur_buffer(s_etat_processus);
+     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
+     sys_free(s_etat_processus);
+     sys_free(arg_exec);
  #   ifdef DEBUG_MEMOIRE
-     debug_memoire_verification(s_etat_processus);
+     debug_memoire_verification();
+     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 3366  informations(struct_processus *s_etat_pr
+ Line 6291  informations(struct_processus *s_etat_pr
          printf("      -i : fonctionnement interactif\n");
          printf("      -l : licence d'utilisation\n");
          printf("      -n : ignorance du signal HUP\n");
+         printf("      -m : chargement d'un module RPL/SO avant la "
+                 "compilation\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 3387  informations(struct_processus *s_etat_pr
+ Line 6314  informations(struct_processus *s_etat_pr
          printf("      -i : runs the RPL/2 sequencer in interactive mode\n");
          printf("      -l : prints the user licence of the software\n");
          printf("      -n : ignores HUP signal\n");
+         printf("      -m : loads RPL/SO object before compilation\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 3400  informations(struct_processus *s_etat_pr
+ Line 6328  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(struct_processus *s_etat_processus)
+ {
+     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);
+ }
+ #pragma GCC diagnostic pop
  // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.14
changed lines
	Added in v.1.195