--- rpl/src/rpl.c 2012/12/19 09:57:52 1.130 +++ rpl/src/rpl.c 2015/02/01 09:47:19 1.167 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.12 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.20 + Copyright (C) 1989-2015 Dr. BERTRAND Joël This file is part of RPL/2. @@ -23,6 +23,10 @@ #define MAIN_RPL #include "rpl-conv.h" +// Bug de gcc à partir de gcc 4.6 (bug 48544) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wclobbered" + /* ================================================================================ @@ -51,6 +55,8 @@ rplinit(int argc, char *argv[], char *en int erreur_historique; int option_P; + integer8 i; + logical1 core; logical1 debug; logical1 erreur_fichier; @@ -106,7 +112,6 @@ rplinit(int argc, char *argv[], char *en unsigned char *ptr; unsigned char *tampon; - unsigned long i; unsigned long unite_fichier; void *l_element_courant; @@ -127,12 +132,7 @@ rplinit(int argc, char *argv[], char *en setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); -# ifndef SEMAPHORES_NOMMES - sem_init(&semaphore_gestionnaires_signaux, 0, 0); -# else - semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX); - - if (semaphore_gestionnaires_signaux == SEM_FAILED) + if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL) { erreur = d_es_allocation_memoire; @@ -154,18 +154,36 @@ rplinit(int argc, char *argv[], char *en 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) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); -# else - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); -# endif + erreur = d_es_allocation_memoire; + + if ((langue = getenv("LANG")) != NULL) + { + if (strncmp(langue, "fr", 2) == 0) + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } + if (initialisation_etat_processus_readline() != 0) + { erreur = d_es_allocation_memoire; if ((langue = getenv("LANG")) != NULL) @@ -199,14 +217,6 @@ rplinit(int argc, char *argv[], char *en if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); -# else - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); -# endif - if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); @@ -219,16 +229,8 @@ rplinit(int argc, char *argv[], char *en return(EXIT_FAILURE); } - if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL) + if ((arg_exec = sys_malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); -# else - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); -# endif - if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); @@ -241,12 +243,12 @@ rplinit(int argc, char *argv[], char *en return(EXIT_FAILURE); } - for(i = 0; i < (unsigned long) argc; i++) + for(i = 0; i < argc; i++) { arg_exec[i] = argv[i]; } - argv[argc] = NULL; + arg_exec[argc] = NULL; initialisation_contexte_cas(s_etat_processus); @@ -259,7 +261,20 @@ rplinit(int argc, char *argv[], char *en 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_pile_processus), + &attributs_mutex); + pthread_mutexattr_destroy(&attributs_mutex); + + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); + pthread_mutex_init(&((*s_etat_processus).mutex_interruptions), + &attributs_mutex); + pthread_mutexattr_destroy(&attributs_mutex); + + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); + pthread_mutex_init(&((*s_etat_processus).mutex_signaux), + &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); pthread_mutexattr_init(&attributs_mutex); @@ -269,6 +284,12 @@ rplinit(int argc, char *argv[], char *en 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); @@ -284,16 +305,7 @@ rplinit(int argc, char *argv[], char *en if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), pthread_self(), SEM_FORK)) == SEM_FAILED) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); -# else - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); -# endif - - liberation(contexte_cas(s_etat_processus); + liberation_contexte_cas(s_etat_processus); if ((*s_etat_processus).langue == 'F') { @@ -324,15 +336,10 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif @@ -356,26 +363,21 @@ rplinit(int argc, char *argv[], char *en } else { -# ifndef SEMAPHORES_NOMMES - sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); - sem_destroy(&((*s_etat_processus).semaphore_fork)); -# else - sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), - pthread_self(), SEM_FORK); -# endif - - liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); - 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"); @@ -400,20 +402,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); if ((*s_etat_processus).langue == 'F') { @@ -430,16 +427,20 @@ rplinit(int argc, char *argv[], char *en 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 à 2012, 2013 BERTRAND Joël\n"); - } - else + if (resultats == NULL) // Appel direct { - printf("+++Copyright (C) 1989 to 2012, 2013 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 à 2014, 2015 BERTRAND Joël\n"); + } + else + { + printf("+++Copyright (C) 1989 to 2014, 2015 BERTRAND Joel\n"); + } } if (getenv("HOME") != NULL) @@ -470,20 +471,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); erreur = d_es_signal; @@ -517,20 +513,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -558,20 +549,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -593,7 +579,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGINT); + raise(SIGINT); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -607,20 +593,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -645,20 +626,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -680,7 +656,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGTERM); + raise(SIGTERM); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -694,20 +670,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -732,20 +703,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -767,7 +733,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGALRM); + raise(SIGALRM); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -781,20 +747,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -822,20 +783,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -855,7 +811,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGTSTP); + raise(SIGTSTP); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -869,20 +825,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -910,20 +861,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -945,7 +891,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGPIPE); + raise(SIGPIPE); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -959,20 +905,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1000,20 +941,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1035,7 +971,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGUSR1); + raise(SIGUSR1); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -1049,20 +985,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), - SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1154,21 +1085,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1198,21 +1124,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1245,25 +1166,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1308,25 +1222,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1365,21 +1272,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1408,21 +1310,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1453,21 +1350,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1498,21 +1390,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1542,21 +1429,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1587,21 +1469,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1624,21 +1501,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1661,21 +1533,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1707,21 +1574,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1761,21 +1623,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1806,21 +1663,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1843,21 +1695,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1888,21 +1735,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1933,21 +1775,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -1978,21 +1815,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2015,21 +1847,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2063,25 +1890,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2124,25 +1944,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2178,21 +1991,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2213,26 +2021,22 @@ rplinit(int argc, char *argv[], char *en } 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_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2253,7 +2057,7 @@ rplinit(int argc, char *argv[], char *en } (*s_etat_processus).longueur_definitions_chainees = - strlen((*s_etat_processus) + (integer8) strlen((*s_etat_processus) .definitions_chainees); break; @@ -2265,21 +2069,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2313,25 +2112,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2374,25 +2166,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2427,21 +2212,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2493,31 +2273,19 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post( - &semaphore_gestionnaires_signaux - ); - sem_destroy( - &semaphore_gestionnaires_signaux - ); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post( - semaphore_gestionnaires_signaux - ); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas( s_etat_processus); - liberation_queue_signaux( + destruction_queue_signaux( s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY @@ -2549,21 +2317,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2593,21 +2356,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2722,21 +2480,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2765,21 +2518,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2800,7 +2548,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGSEGV); + raise(SIGSEGV); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -2814,21 +2562,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2858,21 +2601,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2900,7 +2638,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - kill(getpid(), SIGBUS); + raise(SIGBUS); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -2914,21 +2652,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -2968,21 +2701,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3039,21 +2767,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3083,21 +2806,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3126,21 +2844,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3170,21 +2883,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3213,21 +2921,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3279,20 +2982,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3339,20 +3037,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3403,6 +3096,7 @@ rplinit(int argc, char *argv[], char *en (*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; @@ -3605,20 +3299,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3648,20 +3337,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3705,20 +3389,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3795,20 +3474,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3847,20 +3521,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3927,20 +3596,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -3983,20 +3647,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4079,21 +3738,16 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4139,20 +3793,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4226,20 +3875,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4274,20 +3918,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4323,20 +3962,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4371,20 +4005,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4424,20 +4053,15 @@ rplinit(int argc, char *argv[], char *en { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4482,7 +4106,7 @@ rplinit(int argc, char *argv[], char *en { (*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) { @@ -4492,25 +4116,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4562,25 +4179,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4613,25 +4223,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4663,27 +4266,23 @@ rplinit(int argc, char *argv[], char *en (*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_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4729,25 +4328,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4781,21 +4373,16 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4821,25 +4408,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4874,21 +4454,16 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); - sem_destroy3((*s_etat_processus).semphore_fork, + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4904,6 +4479,8 @@ rplinit(int argc, char *argv[], char *en return(EXIT_FAILURE); } + empilement_pile_systeme(s_etat_processus); + if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur) { @@ -4915,30 +4492,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post( - &semaphore_gestionnaires_signaux - ); - sem_destroy( - &semaphore_gestionnaires_signaux - ); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post( - semaphore_gestionnaires_signaux - ); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -4974,25 +4539,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -5018,30 +4576,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post( - &semaphore_gestionnaires_signaux - ); - sem_destroy( - &semaphore_gestionnaires_signaux - ); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post( - semaphore_gestionnaires_signaux - ); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -5077,25 +4623,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy( - &semaphore_gestionnaires_signaux); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -5138,15 +4677,95 @@ rplinit(int argc, char *argv[], char *en if (erreur == d_absence_erreur) { - if (((*s_etat_processus).var_volatile_alarme - == 0) && ((*s_etat_processus) + 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); + } + } } } } @@ -5159,15 +4778,95 @@ rplinit(int argc, char *argv[], char *en if (erreur == d_absence_erreur) { - if (((*s_etat_processus).var_volatile_alarme - == 0) && ((*s_etat_processus) + 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); + } + } } } } @@ -5208,7 +4907,8 @@ rplinit(int argc, char *argv[], char *en 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; @@ -5380,8 +5080,7 @@ rplinit(int argc, char *argv[], char *en l_element_courant = (void *) (*s_etat_processus).l_base_pile_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++) @@ -5409,30 +5108,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post( - &semaphore_gestionnaires_signaux - ); - sem_destroy( - &semaphore_gestionnaires_signaux - ); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post( - semaphore_gestionnaires_signaux - ); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -5445,8 +5132,8 @@ rplinit(int argc, char *argv[], char *en } # endif - pthread_mutex_unlock( - &((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); return(EXIT_FAILURE); } @@ -5472,30 +5159,18 @@ rplinit(int argc, char *argv[], char *en # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); - sem_post( - &semaphore_gestionnaires_signaux - ); - sem_destroy( - &semaphore_gestionnaires_signaux - ); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); - sem_post( - semaphore_gestionnaires_signaux - ); - sem_destroy2( - semaphore_gestionnaires_signaux, - getpid(), SEM_SIGNAUX); sem_destroy3((*s_etat_processus) - .semphore_fork, getpid(), + .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); - liberation_queue_signaux(s_etat_processus); + destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); @@ -5508,14 +5183,15 @@ rplinit(int argc, char *argv[], char *en } # endif - pthread_mutex_unlock( - &((*s_etat_processus).mutex)); + 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) @@ -5524,12 +5200,18 @@ rplinit(int argc, char *argv[], char *en s_etat_processus); } + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_interruptions)); + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); nanosleep(&attente, NULL); scrutation_interruptions(s_etat_processus); - pthread_mutex_lock(&((*s_etat_processus).mutex)); + 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); @@ -5721,8 +5403,9 @@ rplinit(int argc, char *argv[], char *en { free((*resultats)); - if (((*resultats) = malloc(((*s_etat_processus) - .hauteur_pile_operationnelle + 1) + if (((*resultats) = malloc(((size_t) + ((*s_etat_processus) + .hauteur_pile_operationnelle + 1)) * sizeof(unsigned char **))) != NULL) { (*resultats)[(*s_etat_processus) @@ -6041,8 +5724,10 @@ rplinit(int argc, char *argv[], char *en 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); @@ -6057,14 +5742,6 @@ rplinit(int argc, char *argv[], char *en free((*s_etat_processus).localisation); -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux); -# else - sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); -# endif - destruction_queue_signaux(s_etat_processus); liberation_contexte_cas(s_etat_processus); @@ -6072,14 +5749,20 @@ rplinit(int argc, char *argv[], char *en if ((*s_etat_processus).requete_redemarrage == d_vrai) { - chdir(repertoire_initial); - execvp(arg_exec[0], &(arg_exec[0])); + if (chdir(repertoire_initial) == 0) + { + execvp(arg_exec[0], &(arg_exec[0])); + } + erreur = d_erreur; } - free(arg_exec); + sys_free(arg_exec); arret_thread_signaux(s_etat_processus); - free(s_etat_processus); + 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(); @@ -6205,7 +5888,7 @@ controle_integrite(struct_processus *s_e unsigned char * -date_compilation() +date_compilation(struct_processus *s_etat_processus) { unsigned char *date; @@ -6220,4 +5903,6 @@ date_compilation() return(date); } +#pragma GCC diagnostic pop + // vim: ts=4