--- rpl/src/rpl.c	2010/04/28 06:41:06	1.20
+++ rpl/src/rpl.c	2016/03/15 16:31:15	1.178
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.15
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.25
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -21,7 +21,11 @@
 
 
 #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"
 
 
 /*
@@ -31,16 +35,27 @@
 */
 
 int
-rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home)
+rplinit(int argc, char *argv[], char *envp[],
+		unsigned char ***resultats, char *rpl_home)
 {
-#	include								"copyright.conv.h"
-#	include								"licence.conv.h"
+#	include								"copyright-conv.h"
+#	include								"licence-conv.h"
+
+	char								**arg_exec;
+
+#	ifdef HAVE_STACK_OVERFLOW_RECOVERY
+	char								pile_signaux[SIGSTKSZ];
+#	endif
+
+#	define RPL_PATH_MAX					1024
+	char								repertoire_initial[RPL_PATH_MAX];
 
 	file								*f_source;
 
 	int									erreur_historique;
 	int									option_P;
-	int									status;
+
+	integer8							i;
 
 	logical1							core;
 	logical1							debug;
@@ -71,7 +86,14 @@ rplinit(int argc, char *argv[], unsigned
 
 	struct_processus					*s_etat_processus;
 
-	struct_table_variables_partagees	s_variables_partagees;
+	struct_liste_variables_partagees	*l_element_partage_courant;
+	struct_liste_variables_partagees	*l_element_partage_suivant;
+
+	struct_liste_variables_statiques	*l_element_statique_courant;
+	struct_liste_variables_statiques	*l_element_statique_suivant;
+
+	struct_arbre_variables_partagees	*s_arbre_variables_partagees;
+	struct_liste_variables_partagees	*l_liste_variables_partagees;
 
 	struct sigaction					action;
 	struct sigaction					registre;
@@ -90,7 +112,6 @@ rplinit(int argc, char *argv[], unsigned
 	unsigned char						*ptr;
 	unsigned char						*tampon;
 
-	unsigned long						i;
 	unsigned long						unite_fichier;
 
 	void								*l_element_courant;
@@ -99,22 +120,19 @@ rplinit(int argc, char *argv[], unsigned
 	volatile int						erreur;
 	volatile unsigned char				traitement_fichier_temporaire;
 
+	errno = 0;
+	s_queue_signaux = NULL;
+	routine_recursive = 0;
+	pid_processus_pere = getpid();
+
+#	ifdef DEBUG_MEMOIRE
+	debug_memoire_initialisation();
+#	endif
+
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_init(&semaphore_liste_threads, 0, 1);
-	sem_init(&semaphore_gestionnaires_signaux, 0, 0);
-	sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
-#	else
-	semaphore_liste_threads = sem_init2(1, sem_liste_threads);
-	semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
-	semaphore_gestionnaires_signaux_atomique = sem_init2(1,
-			sem_gestionnaires_signaux_atomique);
-
-	if ((semaphore_liste_threads == SEM_FAILED) ||
-			(semaphore_gestionnaires_signaux == SEM_FAILED) ||
-			(semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
+	if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL)
 	{
 		erreur = d_es_allocation_memoire;
 
@@ -136,9 +154,35 @@ rplinit(int argc, char *argv[], unsigned
 
 		return(EXIT_FAILURE);
 	}
-#	endif
 
-	if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
+	(*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;
 
@@ -171,25 +215,141 @@ rplinit(int argc, char *argv[], unsigned
 		(*s_etat_processus).langue = 'E';
 	}
 
+	if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
+	{
+		if ((*s_etat_processus).langue == 'F')
+		{
+			uprintf("+++Système : Mémoire insuffisante\n");
+		}
+		else
+		{
+			uprintf("+++System : Not enough memory\n");
+		}
+
+		return(EXIT_FAILURE);
+	}
+
+	if ((arg_exec = 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), &attributs_mutex);
+	pthread_mutex_init(&((*s_etat_processus).mutex_interruptions),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+	pthread_mutex_init(&((*s_etat_processus).mutex_signaux),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	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).mutex_allocation_buffer),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	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);
+		sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
 #	else
-	if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==
-			SEM_FAILED)
+		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).protection_liste_mutexes),
+			&attributs_mutex);
+	pthread_mutexattr_destroy(&attributs_mutex);
+
+	(*s_etat_processus).chemin_fichiers_temporaires =
+			recherche_chemin_fichiers_temporaires(s_etat_processus);
+
+	insertion_thread(s_etat_processus, d_vrai);
+	creation_queue_signaux(s_etat_processus);
+
+	if ((*s_etat_processus).erreur_systeme != d_es)
 	{
+#		ifndef SEMAPHORES_NOMMES
+			sem_post(&((*s_etat_processus).semaphore_fork));
+			sem_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')
 		{
 			uprintf("+++Système : Mémoire insuffisante\n");
@@ -201,27 +361,43 @@ rplinit(int argc, char *argv[], unsigned
 
 		return(EXIT_FAILURE);
 	}
-#	endif
 
-	pthread_mutexattr_init(&attributs_mutex);
-	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
-	pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
-			&attributs_mutex);
-	pthread_mutexattr_destroy(&attributs_mutex);
+	if (d_forced_locale == 0)
+	{
+		localisation_courante(s_etat_processus);
+	}
+	else
+	{
+		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
 
-	(*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees;
+			liberation_contexte_cas(s_etat_processus);
+			destruction_queue_signaux(s_etat_processus);
 
-	s_variables_partagees.nombre_variables = 0;
-	s_variables_partagees.nombre_variables_allouees = 0;
-	s_variables_partagees.table = NULL;
+			if ((*s_etat_processus).langue == 'F')
+			{
+				uprintf("+++Système : Mémoire insuffisante\n");
+			}
+			else
+			{
+				uprintf("+++System : Not enough memory\n");
+			}
 
-	pthread_mutexattr_init(&attributs_mutex);
-	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
-	pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees))
-			.mutex), &attributs_mutex);
-	pthread_mutexattr_destroy(&attributs_mutex);
+			return(EXIT_FAILURE);
+		}
+
+		strcpy((*s_etat_processus).localisation, d_locale);
+	}
 
-	localisation_courante(s_etat_processus);
 	(*s_etat_processus).erreur_systeme = d_es;
 
 	if ((*s_etat_processus).localisation == NULL)
@@ -229,6 +405,18 @@ rplinit(int argc, char *argv[], unsigned
 		if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
 				sizeof(unsigned char))) == NULL)
 		{
+#			ifndef SEMAPHORES_NOMMES
+				sem_post(&((*s_etat_processus).semaphore_fork));
+				sem_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");
@@ -244,16 +432,20 @@ rplinit(int argc, char *argv[], unsigned
 		strcpy((*s_etat_processus).localisation, d_locale);
 	}
 
-	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 à 2009, 2010 BERTRAND Joël\n");
-	}
-	else
+	if (resultats == NULL) // Appel direct
 	{
-		printf("+++Copyright (C) 1989 to 2009, 2010 BERTRAND Joel\n");
+		printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
+				((*s_etat_processus).langue == 'F')
+				? d_date_rpl : d_date_en_rpl);
+
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("+++Copyright (C) 1989 à 2015, 2016 BERTRAND Joël\n");
+		}
+		else
+		{
+			printf("+++Copyright (C) 1989 to 2015, 2016 BERTRAND Joel\n");
+		}
 	}
 
 	if (getenv("HOME") != NULL)
@@ -278,89 +470,181 @@ 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);
+
+			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
 		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");
 		}
-
-		return(EXIT_FAILURE);
-	}
-
-#	ifndef SEMAPHORES_NOMMES
-	if (pthread_setspecific(semaphore_fork_processus_courant,
-			&((*s_etat_processus).semaphore_fork)) != 0)
-#	else
-	if (pthread_setspecific(semaphore_fork_processus_courant,
-			(*s_etat_processus).semaphore_fork) != 0)
 #	endif
+
+	if (lancement_thread_signaux(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
+
+		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);
 	}
 
-	// Initialisation d'une pile de signal pour récupérer les
-	// débordement de pile
+	action.sa_handler = interruption1;
+	action.sa_flags = 0;
 
-#	ifndef Cygwin
-	if (((*s_etat_processus).pile_signal.ss_sp =
-			malloc((*s_etat_processus).pile_signal.ss_size =
-			SIGSTKSZ)) == NULL)
+	if (sigaction(SIGINT, &action, NULL) != 0)
 	{
-		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;
 
-	if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 0)
+	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
 	{
+		nanosleep(&attente, NULL);
+	}
+
+	if (signal_test != SIGINT)
+	{
+#		ifndef SEMAPHORES_NOMMES
+			sem_post(&((*s_etat_processus).semaphore_fork));
+			sem_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"
-					" impossible\n");
+			printf("+++Système : Initialisation des signaux POSIX "
+					"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;
-	action.sa_flags = SA_ONSTACK | SA_SIGINFO;
 
-	if (sigaction(SIGINT, &action, NULL) != 0)
+	if (sigaction(SIGTERM, &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')
@@ -376,11 +660,37 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption2;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+	signal_test = SIGTEST;
+	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 "
@@ -394,11 +704,26 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption4;
-	action.sa_flags = SA_ONSTACK | SA_SIGINFO;
-
-	if (sigaction(SIGSTART, &action, NULL) != 0)
+	if (sigaction(SIGALRM, &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 "
@@ -412,8 +737,37 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	if (sigaction(SIGCONT, &action, NULL) != 0)
+	signal_test = SIGTEST;
+	raise(SIGALRM);
+
+	attente.tv_sec = 0;
+	attente.tv_nsec = 1000000;
+
+	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+	{
+		nanosleep(&attente, NULL);
+	}
+
+	if (signal_test != SIGALRM)
 	{
+#		ifndef SEMAPHORES_NOMMES
+			sem_post(&((*s_etat_processus).semaphore_fork));
+			sem_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 "
@@ -427,12 +781,26 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption5;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+	action.sa_handler = interruption2;
+	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')
 		{
@@ -447,11 +815,35 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption8;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+	signal_test = SIGTEST;
+	raise(SIGTSTP);
 
-	if (sigaction(SIGURG, &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 != 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')
@@ -467,11 +859,27 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption7;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+	action.sa_handler = interruption5;
+	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')
@@ -487,11 +895,35 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption6;
-	action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+	signal_test = SIGTEST;
+	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')
@@ -507,11 +939,27 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption9;
-	action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+	action.sa_handler = interruption1;
+	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')
@@ -527,11 +975,35 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption1;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
+	signal_test = SIGTEST;
+	raise(SIGUSR1);
 
-	if (sigaction(SIGALRM, &action, NULL) != 0)
+	attente.tv_sec = 0;
+	attente.tv_nsec = 1000000;
+
+	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+	{
+		nanosleep(&attente, NULL);
+	}
+
+	if (signal_test != SIGUSR1)
 	{
+#		ifndef SEMAPHORES_NOMMES
+			sem_post(&((*s_etat_processus).semaphore_fork));
+			sem_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')
@@ -547,11 +1019,7 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
-	action.sa_sigaction = interruption3;
-	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
-
-	(*s_etat_processus).chemin_fichiers_temporaires =
-			recherche_chemin_fichiers_temporaires(s_etat_processus);
+	signal_test = SIGTEST + 1;
 
 	erreur = d_absence_erreur;
 	core = d_faux;
@@ -599,6 +1067,15 @@ 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] == '-')
@@ -611,6 +1088,23 @@ 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 "
@@ -633,6 +1127,23 @@ 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 "
@@ -657,6 +1168,26 @@ 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 "
@@ -693,6 +1224,26 @@ 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 "
@@ -724,6 +1275,23 @@ 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 "
@@ -745,6 +1313,23 @@ 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 "
@@ -768,6 +1353,23 @@ 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 "
@@ -791,6 +1393,23 @@ 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 "
@@ -813,6 +1432,23 @@ 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 "
@@ -836,6 +1472,23 @@ 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 "
@@ -851,6 +1504,23 @@ 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 "
@@ -866,6 +1536,23 @@ 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 "
@@ -890,6 +1577,23 @@ 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 "
@@ -922,6 +1626,23 @@ rplinit(int argc, char *argv[], unsigned
 						{
 							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 "
@@ -945,6 +1666,23 @@ 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 "
@@ -960,6 +1698,23 @@ 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 "
@@ -983,6 +1738,23 @@ 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 "
@@ -1006,6 +1778,23 @@ 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 "
@@ -1029,6 +1818,23 @@ 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 "
@@ -1044,6 +1850,23 @@ 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 "
@@ -1069,6 +1892,26 @@ 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 "
@@ -1103,6 +1946,26 @@ 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 "
@@ -1131,6 +1994,23 @@ 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 "
@@ -1146,9 +2026,27 @@ rplinit(int argc, char *argv[], unsigned
 							}
 
 							if (((*s_etat_processus).definitions_chainees =
-									compactage((*s_etat_processus)
-									.definitions_chainees)) == NULL)
+									compactage(s_etat_processus,
+									(*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 "
@@ -1164,7 +2062,7 @@ rplinit(int argc, char *argv[], unsigned
 							}
 
 							(*s_etat_processus).longueur_definitions_chainees =
-									strlen((*s_etat_processus)
+									(integer8) strlen((*s_etat_processus)
 									.definitions_chainees);
 
 							break;
@@ -1174,6 +2072,23 @@ 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 "
@@ -1199,6 +2114,26 @@ 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 "
@@ -1233,6 +2168,26 @@ 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 "
@@ -1260,6 +2215,23 @@ 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 "
@@ -1303,6 +2275,28 @@ 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 "
@@ -1326,6 +2320,23 @@ 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 "
@@ -1348,6 +2359,23 @@ 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 "
@@ -1394,6 +2422,12 @@ rplinit(int argc, char *argv[], unsigned
 							break;
 						}
 
+						case '-':
+						case ' ':
+						{
+							break;
+						}
+
 						default :
 						{
 							if ((*s_etat_processus).langue == 'F')
@@ -1438,10 +2472,72 @@ 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 "
@@ -1456,8 +2552,82 @@ 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 "
@@ -1471,15 +2641,93 @@ rplinit(int argc, char *argv[], unsigned
 
 				return(EXIT_FAILURE);
 			}
+
+			signal_test = SIGTEST;
+			raise(SIGBUS);
+
+			attente.tv_sec = 0;
+			attente.tv_nsec = 1000000;
+
+			for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
+			{
+				nanosleep(&attente, NULL);
+			}
+
+			if (signal_test != SIGBUS)
+			{
+#				ifndef SEMAPHORES_NOMMES
+					sem_post(&((*s_etat_processus).semaphore_fork));
+					sem_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 "
+							"impossible\n");
+				}
+				else
+				{
+					printf("+++System : Initialization of POSIX signals "
+							"failed\n");
+				}
+
+				return(EXIT_FAILURE);
+			}
+
 		}
 
 		if (option_n == d_vrai)
 		{
-			action.sa_sigaction = interruption10;
-			action.sa_flags = SA_ONSTACK | SA_SIGINFO;
+			action.sa_handler = interruption4;
+			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 "
@@ -1522,6 +2770,30 @@ 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");
@@ -1537,6 +2809,30 @@ 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");
@@ -1551,6 +2847,30 @@ 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");
@@ -1566,6 +2886,30 @@ 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");
@@ -1580,6 +2924,30 @@ 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");
@@ -1617,6 +2985,29 @@ 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')
@@ -1649,6 +3040,29 @@ 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");
@@ -1686,16 +3100,28 @@ rplinit(int argc, char *argv[], unsigned
 			gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);
 
 			(*s_etat_processus).liste_mutexes = NULL;
+			(*s_etat_processus).sections_critiques = 0;
+			(*s_etat_processus).initialisation_scheduler = d_faux;
 
 			(*s_etat_processus).test_instruction = 'N';
 			(*s_etat_processus).nombre_arguments = 0;
 			(*s_etat_processus).affichage_arguments = 'N';
 			(*s_etat_processus).autorisation_conversion_chaine = 'Y';
 			(*s_etat_processus).autorisation_evaluation_nom = 'Y';
-			(*s_etat_processus).autorisation_nom_implicite = 'Y';
+
+			if (mode_interactif == d_vrai)
+			{
+				(*s_etat_processus).autorisation_nom_implicite = 'Y';
+			}
+			else
+			{
+				(*s_etat_processus).autorisation_nom_implicite = 'N';
+			}
+
 			(*s_etat_processus).autorisation_empilement_programme = 'N';
 			(*s_etat_processus).requete_arret = 'N';
 			(*s_etat_processus).evaluation_forcee = 'N';
+			(*s_etat_processus).recherche_type = 'N';
 
 			(*s_etat_processus).constante_symbolique = 'N';
 			(*s_etat_processus).traitement_symbolique = 'N';
@@ -1707,19 +3133,23 @@ 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_etat_processus).nombre_variables_allouees = 0;
-			(*s_etat_processus).s_liste_variables_statiques = NULL;
-			(*s_etat_processus).nombre_variables_statiques = 0;
-			(*s_etat_processus).nombre_variables_statiques_allouees = 0;
+			s_arbre_variables_partagees = NULL;
+			l_liste_variables_partagees = NULL;
+			(*s_etat_processus).s_arbre_variables_partagees =
+					&s_arbre_variables_partagees;
+			(*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;
@@ -1841,14 +3271,18 @@ rplinit(int argc, char *argv[], unsigned
 			}
 
 			(*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;
@@ -1857,12 +3291,40 @@ 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");
@@ -1876,8 +3338,31 @@ 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')
@@ -1907,6 +3392,29 @@ 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')
@@ -1927,7 +3435,7 @@ 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;
 			}
@@ -1936,12 +3444,10 @@ rplinit(int argc, char *argv[], unsigned
 				(*((*s_etat_processus).l_base_pile_systeme))
 						.retour_definition = 'Y';
 
-				(*s_etat_processus).indep = (struct_objet *) malloc(
-						sizeof(struct_objet));
-				(*s_etat_processus).depend = (struct_objet *) malloc(
-						sizeof(struct_objet));
+				(*s_etat_processus).indep = allocation(s_etat_processus, NON);
+				(*s_etat_processus).depend = allocation(s_etat_processus, NON);
 				(*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) &&
@@ -1971,6 +3477,29 @@ 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')
@@ -1995,6 +3524,29 @@ 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')
@@ -2047,6 +3599,29 @@ 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')
@@ -2075,6 +3650,29 @@ 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')
@@ -2135,20 +3733,6 @@ 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';
 
@@ -2157,6 +3741,30 @@ 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 :"
@@ -2188,6 +3796,29 @@ rplinit(int argc, char *argv[], unsigned
 					if ((erreur = compilation(s_etat_processus)) !=
 							d_absence_erreur)
 					{
+#						ifndef SEMAPHORES_NOMMES
+							sem_post(&((*s_etat_processus).semaphore_fork));
+							sem_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)
@@ -2245,8 +3876,31 @@ 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");
@@ -2267,6 +3921,29 @@ 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");
@@ -2288,6 +3965,29 @@ 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");
@@ -2305,10 +4005,32 @@ rplinit(int argc, char *argv[], unsigned
 						return(EXIT_FAILURE);
 					}
 
-					if ((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus)
-							.position_variable_courante].niveau != 0)
+					if ((*(*s_etat_processus).pointeur_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");
@@ -2334,6 +4056,29 @@ 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')
@@ -2352,6 +4097,11 @@ 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);
 
@@ -2361,13 +4111,40 @@ 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')
@@ -2393,8 +4170,6 @@ rplinit(int argc, char *argv[], unsigned
 
 					fflush(stdout);
 
-					initialisation_instructions(s_etat_processus);
-
 					if (arguments != NULL)
 					{
 						tampon = (*s_etat_processus).definitions_chainees;
@@ -2406,6 +4181,33 @@ 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')
@@ -2423,6 +4225,33 @@ 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 "
@@ -2442,10 +4271,35 @@ 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)
 							{
@@ -2476,6 +4330,33 @@ 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')
@@ -2495,6 +4376,30 @@ 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);
 						}
 
@@ -2505,6 +4410,34 @@ 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')
@@ -2524,9 +4457,35 @@ 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)
 						{
@@ -2535,6 +4494,33 @@ 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')
@@ -2555,6 +4541,34 @@ 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);
 							}
 
@@ -2564,6 +4578,33 @@ 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')
@@ -2584,6 +4625,33 @@ 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);
 							}
 						}
@@ -2611,6 +4679,100 @@ rplinit(int argc, char *argv[], unsigned
 							if (setjmp(contexte_initial) == 0)
 							{
 								erreur = sequenceur(s_etat_processus);
+
+								if (erreur == d_absence_erreur)
+								{
+									if (((*s_etat_processus)
+											.arret_depuis_abort == 0) &&
+											((*s_etat_processus).at_exit
+											!= NULL))
+									{
+										// Permet de traiter ATEXIT
+										// même après réception d'un SIGINT.
+										(*s_etat_processus)
+												.var_volatile_alarme = 0;
+										(*s_etat_processus)
+												.var_volatile_requete_arret = 0;
+
+										if ((*s_etat_processus).profilage ==
+												d_vrai)
+										{
+											profilage(s_etat_processus,
+													"ATEXIT");
+										}
+
+										erreur = evaluation(s_etat_processus,
+												(*s_etat_processus).at_exit,
+												'E');
+
+										if ((*s_etat_processus).profilage ==
+												d_vrai)
+										{
+											profilage(s_etat_processus, NULL);
+										}
+
+										if (((*s_etat_processus)
+												.erreur_execution != d_ex) ||
+												((*s_etat_processus).exception
+												!= d_ep) || ((*s_etat_processus)
+												.erreur_systeme != d_es))
+										{
+											printf("%s [%d]\n", message =
+													messages(s_etat_processus),
+													(int) getpid());
+											free(message);
+
+											if (test_cfsf(s_etat_processus, 51)
+													== d_faux)
+											{
+												printf("%s", ds_beep);
+											}
+
+											if ((*s_etat_processus).core ==
+													d_vrai)
+											{
+												printf("\n");
+
+												if ((*s_etat_processus).langue
+														== 'F')
+												{
+													printf("+++Information : Gé"
+															"nération du fichie"
+															"r rpl-core "
+															"[%d]\n", (int)
+															getpid());
+												}
+												else
+												{
+													printf("+++Information : Wr"
+															"iting rpl-core fil"
+															"e [%d]\n",
+															(int) getpid());
+												}
+
+												rplcore(s_etat_processus);
+
+												if ((*s_etat_processus).langue
+														== 'F')
+												{
+													printf("+++Information : Pr"
+															"ocessus tracé [%d]"
+															"\n",
+															(int) getpid());
+												}
+												else
+												{
+													printf("+++Information : Do"
+															"ne [%d]\n", (int)
+															getpid());
+												}
+
+												printf("\n");
+												fflush(stdout);
+											}
+										}
+									}
+								}
 							}
 						}
 						else
@@ -2618,19 +4780,112 @@ rplinit(int argc, char *argv[], unsigned
 							if (setjmp(contexte_initial) == 0)
 							{
 								erreur = sequenceur_optimise(s_etat_processus);
-							}
-						}
 
-						if (erreur == d_absence_erreur)
-						{
-							erreur = evaluation(s_etat_processus,
-									(*s_etat_processus).at_exit, 'E');
+								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);
+											}
+										}
+									}
+								}
+							}
 						}
+					}
 
-						liberation(s_etat_processus,
-								(*s_etat_processus).at_exit);
+					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);
@@ -2639,16 +4894,6 @@ 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);
@@ -2667,7 +4912,8 @@ 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;
@@ -2740,17 +4986,31 @@ rplinit(int argc, char *argv[], unsigned
 						{
 							if ((*s_etat_processus).var_volatile_alarme != 0)
 							{
-								kill((*(*((struct_processus_fils *)
+								envoi_signal_processus(
+										(*(*((struct_processus_fils *)
 										(*(*((struct_liste_chainee *)
 										l_element_courant)).donnee).objet))
-										.thread).pid, SIGURG);
+										.thread).pid, rpl_sigurg);
 							}
 							else
 							{
-								kill((*(*((struct_processus_fils *)
-										(*(*((struct_liste_chainee *)
-										l_element_courant)).donnee).objet))
-										.thread).pid, SIGFSTOP);
+								if ((*s_etat_processus).arret_depuis_abort
+										== -1)
+								{
+									envoi_signal_processus(
+											(*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, rpl_sigabort);
+								}
+								else
+								{
+									envoi_signal_processus(
+											(*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, rpl_sigstop);
+								}
 							}
 						}
 						else
@@ -2768,17 +5028,33 @@ 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 *)
-											(*(*((struct_liste_chainee *)
-											l_element_courant)).donnee).objet))
-											.thread).tid, SIGFSTOP);
+									if ((*s_etat_processus).arret_depuis_abort
+											== -1)
+									{
+										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);
+									}
 								}
 							}
 
@@ -2806,20 +5082,10 @@ 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)
-								.nombre_interruptions_non_affectees != 0)
-						{
-							affectation_interruptions_logicielles(
-									s_etat_processus);
-						}
-
-						for(i = 0; i < (unsigned long)
-								(*(*((struct_processus_fils *)
+						for(i = 0; i < (*(*((struct_processus_fils *)
 								(*(*((struct_liste_chainee *)
 								l_element_courant)).donnee).objet)).thread)
 								.nombre_objets_dans_pipe; i++)
@@ -2839,13 +5105,40 @@ 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(
-											&((*s_etat_processus).mutex));
+#									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
+
+									pthread_mutex_unlock(&((*s_etat_processus)
+											.mutex_pile_processus));
 									return(EXIT_FAILURE);
 								}
 
@@ -2868,19 +5161,62 @@ rplinit(int argc, char *argv[], unsigned
 								if (sigaction(SIGPIPE, &registre, NULL)
 										!= 0)
 								{
-									pthread_mutex_unlock(
-											&((*s_etat_processus).mutex));
+#									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
+
+									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);
@@ -3030,40 +5366,34 @@ rplinit(int argc, char *argv[], unsigned
 					 * le libérer...
 					 */
 
-					for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
-					{
-						liberation(s_etat_processus,
-								(*s_etat_processus).s_liste_variables[i].objet);
-						free((*s_etat_processus).s_liste_variables[i].nom);
-					}
+					liberation_arbre_variables_partagees(s_etat_processus,
+							(*(*s_etat_processus).s_arbre_variables_partagees));
+					liberation_arbre_variables(s_etat_processus,
+							(*s_etat_processus).s_arbre_variables, d_vrai);
+					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)
-							.nombre_variables_statiques; i++)
+					while(l_element_statique_courant != NULL)
 					{
-						liberation(s_etat_processus, (*s_etat_processus)
-								.s_liste_variables_statiques[i].objet);
-						free((*s_etat_processus)
-								.s_liste_variables_statiques[i].nom);
+						l_element_statique_suivant =
+							(*l_element_statique_courant).suivant;
+						free(l_element_statique_courant);
+						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)
-							.s_liste_variables_partagees)).nombre_variables;
-							i++)
+					while(l_element_partage_courant != NULL)
 					{
-						liberation(s_etat_processus, (*((*s_etat_processus)
-								.s_liste_variables_partagees)).table[i].objet);
-						free((*((*s_etat_processus)
-								.s_liste_variables_partagees)).table[i].nom);
+						l_element_partage_suivant =
+								(*l_element_partage_courant).suivant;
+						free(l_element_partage_courant);
+						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().
@@ -3076,10 +5406,11 @@ rplinit(int argc, char *argv[], unsigned
 					{
 						if ((*resultats) != NULL)
 						{
-							free((*resultats));
+							sys_free((*resultats));
 
-							if (((*resultats) = malloc(((*s_etat_processus)
-									.hauteur_pile_operationnelle + 1)
+							if (((*resultats) = sys_malloc(((size_t)
+									((*s_etat_processus)
+									.hauteur_pile_operationnelle + 1))
 									* sizeof(unsigned char **))) != NULL)
 							{
 								(*resultats)[(*s_etat_processus)
@@ -3345,8 +5676,6 @@ 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)
 					{
@@ -3383,11 +5712,7 @@ rplinit(int argc, char *argv[], unsigned
 
 		if (traitement_fichier_temporaire == 'Y')
 		{
-			if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
-			{
-				return(EXIT_FAILURE);
-			}
-
+			destruction_fichier(nom_fichier_temporaire);
 			free(nom_fichier_temporaire);
 		}
 
@@ -3398,48 +5723,65 @@ 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));
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
+	pthread_mutex_destroy(&mutex_sections_critiques);
+	pthread_mutex_destroy(&mutex_liste_variables_partagees);
+
 #	ifndef SEMAPHORES_NOMMES
 	sem_post(&((*s_etat_processus).semaphore_fork));
 	sem_destroy(&((*s_etat_processus).semaphore_fork));
 #	else
 	sem_post((*s_etat_processus).semaphore_fork);
-	sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
+	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
+			SEM_FORK);
 #	endif
 
 	free((*s_etat_processus).localisation);
-	free(s_etat_processus);
 
-#	ifndef SEMAPHORES_NOMMES
-	sem_destroy(&semaphore_liste_threads);
-#	else
-	sem_destroy2(semaphore_liste_threads, sem_liste_threads);
+	destruction_queue_signaux(s_etat_processus);
+	liberation_contexte_cas(s_etat_processus);
+
+	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;
+	}
+
+	sys_free(arg_exec);
+	liberation_etat_processus_readline();
+	liberation_allocateur_buffer(s_etat_processus);
+	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
+	sys_free(s_etat_processus);
+
+#	ifdef DEBUG_MEMOIRE
+	debug_memoire_verification();
+	analyse_post_mortem();
 #	endif
-#	ifndef SEMAPHORES_NOMMES
-	sem_post(&semaphore_gestionnaires_signaux);
-	sem_destroy(&semaphore_gestionnaires_signaux);
-	sem_destroy(&semaphore_gestionnaires_signaux_atomique);
-#	else
-	sem_post(semaphore_gestionnaires_signaux);
-	sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
-	sem_destroy2(semaphore_gestionnaires_signaux_atomique,
-			sem_gestionnaires_signaux_atomique);
+
+#	ifdef HAVE_STACK_OVERFLOW_RECOVERY
+	stackoverflow_deinstall_handler();
 #	endif
 
-#	ifdef DEBUG_MEMOIRE
-	debug_memoire_verification(s_etat_processus);
+#	ifdef HAVE_SIGSEGV_RECOVERY
+	if (debug == d_faux)
+	{
+		sigsegv_deinstall_handler();
+	}
 #	endif
 
 	return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);
@@ -3464,7 +5806,7 @@ informations(struct_processus *s_etat_pr
 		printf("      -l : licence d'utilisation\n");
 		printf("      -n : ignorance du signal HUP\n");
 		printf("      -p : précompilation du script avant exécution\n");
-		printf("      -P : profilage\n");
+		printf("      -P : profilage (-P ou -PP)\n");
 		printf("      -s : empêchement de l'ouverture de l'écran initial\n");
 		printf("      -S : exécution du script passé en ligne de commande\n");
 		printf("      -t : trace\n");
@@ -3485,7 +5827,7 @@ informations(struct_processus *s_etat_pr
 		printf("      -l : prints the user licence of the software\n");
 		printf("      -n : ignores HUP signal\n");
 		printf("      -p : precompiles script\n");
-		printf("      -P : computes profile data\n");
+		printf("      -P : computes profile data (-P or -PP)\n");
 		printf("      -s : disables splash screen\n");
 		printf("      -S : executes script written in command line\n");
 		printf("      -t : enables tracing mode\n");
@@ -3497,4 +5839,74 @@ 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