/* ================================================================================ RPL/2 (R) version 4.1.20 Copyright (C) 1989-2015 Dr. BERTRAND Joël This file is part of RPL/2. RPL/2 is free software; you can redistribute it and/or modify it under the terms of the CeCILL V2 License as published by the french CEA, CNRS and INRIA. RPL/2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License for more details. You should have received a copy of the CeCILL License along with RPL/2. If not, write to info@cecill.info. ================================================================================ */ #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" /* ================================================================================ Programme principal ================================================================================ */ int rplinit(int argc, char *argv[], char *envp[], unsigned char ***resultats, char *rpl_home) { # include "copyright-conv.h" # include "licence-conv.h" char **arg_exec; # ifdef HAVE_STACK_OVERFLOW_RECOVERY char pile_signaux[SIGSTKSZ]; # endif # define RPL_PATH_MAX 1024 char repertoire_initial[RPL_PATH_MAX]; file *f_source; int erreur_historique; int option_P; integer8 i; logical1 core; logical1 debug; logical1 erreur_fichier; logical1 existence; logical1 mode_interactif; logical1 option_a; logical1 option_A; logical1 option_c; logical1 option_d; logical1 option_D; logical1 option_h; logical1 option_i; logical1 option_l; logical1 option_n; logical1 option_p; logical1 option_s; logical1 option_S; logical1 option_t; logical1 option_v; logical1 ouverture; pthread_mutexattr_t attributs_mutex; ssize_t longueur_ecriture; struct_objet *s_objet; struct_processus *s_etat_processus; 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; struct timespec attente; unsigned char *arguments; unsigned char drapeau_encart; unsigned char *type_debug; unsigned char *home; unsigned char *langue; unsigned char *message; unsigned char *nom_fichier_temporaire; unsigned char option; unsigned char presence_definition; unsigned char *ptr; unsigned char *tampon; unsigned long unite_fichier; void *l_element_courant; void *l_element_suivant; 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); if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) { 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); } (*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 ((langue = getenv("LANG")) != NULL) { (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0) ? 'F' : 'E'; } else { (*s_etat_processus).langue = 'E'; } if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) { if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL) { if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } for(i = 0; i < argc; i++) { arg_exec[i] = argv[i]; } argv[argc] = NULL; initialisation_contexte_cas(s_etat_processus); (*s_etat_processus).exception = d_ep; (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex; (*s_etat_processus).requete_redemarrage = d_faux; (*s_etat_processus).rpl_home = rpl_home; pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*s_etat_processus).mutex_interruptions), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*s_etat_processus).mutex_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_RECURSIVE); pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); # ifndef SEMAPHORES_NOMMES sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); # else if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), pthread_self(), SEM_FORK)) == SEM_FAILED) { liberation_contexte_cas(s_etat_processus); if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } # endif pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*s_etat_processus).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"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } 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 liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } strcpy((*s_etat_processus).localisation, d_locale); } (*s_etat_processus).erreur_systeme = d_es; if ((*s_etat_processus).localisation == NULL) { if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * sizeof(unsigned char))) == NULL) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); } else { uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } strcpy((*s_etat_processus).localisation, d_locale); } if (resultats == NULL) // Appel direct { printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl, ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl); if ((*s_etat_processus).langue == 'F') { printf("+++Copyright (C) 1989 à 2014, 2015 BERTRAND Joël\n"); } else { printf("+++Copyright (C) 1989 to 2014, 2015 BERTRAND Joel\n"); } } if (getenv("HOME") != NULL) { home = getenv("HOME"); } else if ((getenv("USER") != NULL) && (getpwnam(getenv("USER")) != NULL)) { home = getpwnam(getenv("USER"))->pw_dir; } else if ((getenv("LOGNAME") != NULL) && (getpwnam(getenv("LOGNAME")) != NULL)) { home = getpwnam(getenv("LOGNAME"))->pw_dir; } else if ((getuid() != ((uid_t) -1)) && (getpwuid(getuid()) != NULL)) { home = getpwuid(getuid())->pw_dir; } else { home = ""; } # 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 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("+++Attention : Le système ne supporte pas de pile " "alternative\n"); } else { printf("+++Warning : Operating system does not support alternate " "stack\n"); } # 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 : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } action.sa_handler = interruption1; action.sa_flags = 0; if (sigaction(SIGINT, &action, NULL) != 0) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGINT); attente.tv_sec = 0; attente.tv_nsec = 1000000; for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) { nanosleep(&attente, NULL); } if (signal_test != SIGINT) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_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); } 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGTERM); 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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } 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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } 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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } action.sa_handler = interruption2; action.sa_flags = 0; if (sigaction(SIGTSTP, &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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGTSTP); 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGPIPE); 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } action.sa_handler = interruption1; action.sa_flags = 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGUSR1); 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') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST + 1; erreur = d_absence_erreur; core = d_faux; mode_interactif = d_faux; (*s_etat_processus).nom_fichier_source = NULL; (*s_etat_processus).definitions_chainees = NULL; (*s_etat_processus).type_debug = 0; traitement_fichier_temporaire = 'N'; option = ' '; drapeau_encart = 'Y'; debug = d_faux; arguments = NULL; (*s_etat_processus).s_fichiers = NULL; (*s_etat_processus).s_sockets = NULL; (*s_etat_processus).s_connecteurs_sql = NULL; setlogmask(LOG_MASK(LOG_NOTICE)); openlog(argv[0], LOG_ODELAY | LOG_PID, LOG_USER); if (argc == 1) { erreur = d_erreur; informations(s_etat_processus); } else { presence_definition = 'N'; (*s_etat_processus).debug = d_faux; (*s_etat_processus).lancement_interactif = d_faux; option_a = d_faux; option_A = d_faux; option_c = d_faux; option_d = d_faux; option_D = d_faux; option_h = d_faux; option_i = d_faux; option_l = d_faux; option_n = d_faux; option_p = d_faux; option_P = 0; option_s = d_faux; option_S = d_faux; 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] == '-') { while((option = *(++argv[0])) != '\0') { switch(option) { case 'a' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -a " "on command line"); } return(EXIT_FAILURE); } option_a = d_vrai; break; } case 'A' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -A " "on command line"); } return(EXIT_FAILURE); } option_A = d_vrai; while(*(++argv[0]) == ' '); argv[0]--; if ((*(++argv[0])) != '\0') { 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 " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = arguments; (*ptr) = d_code_fin_chaine; strcat(ptr, "<< "); ptr += 3; while(*(argv[0]) != '\0') { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; strcat(arguments, " >>"); argv[0]--; } else if ((--argc) > 0) { argv++; 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 " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = arguments; (*ptr) = d_code_fin_chaine; strcat(ptr, "<< "); ptr += 3; while(*(argv[0]) != '\0') { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; strcat(arguments, " >>"); argv[0]--; } 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 " "spécifié après l'option -A\n"); } else { printf("+++Error : Data required after " "-A option\n"); } return(EXIT_FAILURE); } break; } case 'c' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -c " "on command line"); } return(EXIT_FAILURE); } option_c = d_vrai; core = d_vrai; break; } case 'd' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -d " "on command line"); } return(EXIT_FAILURE); } option_d = d_vrai; debug = d_vrai; break; } case 'D' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -D " "on command line"); } return(EXIT_FAILURE); } option_D = d_vrai; break; } case 'h' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -h " "on command line"); } return(EXIT_FAILURE); } option_h = d_vrai; informations(s_etat_processus); break; } case 'i' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -i " "on command line"); } return(EXIT_FAILURE); } 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 " "incompatibles\n"); } else { printf("+++Error : incompatible options -i " "and -S\n"); } return(EXIT_FAILURE); } 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 " "incompatibles\n"); } else { printf("+++Error : incompatible options -i " "and -p\n"); } return(EXIT_FAILURE); } option_i = d_vrai; mode_interactif = d_vrai; presence_definition = 'O'; break; } case 'l' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -l " "on command line"); } return(EXIT_FAILURE); } option_l = d_vrai; if ((*s_etat_processus).langue == 'F') { printf("%s\n\n", CeCILL_fr); } else { printf("%s\n\n", CeCILL_en); } break; } case 'n' : { if (option_n == d_vrai) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -n présente " "plus d'une fois\n"); } else { printf("+++Error : more than one -n " "on command line"); } return(EXIT_FAILURE); } option_n = d_vrai; break; } case 'p' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -p " "on command line"); } return(EXIT_FAILURE); } 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 " "incompatibles\n"); } else { printf("+++Error : incompatible options -i " "and -p\n"); } return(EXIT_FAILURE); } option_p = d_vrai; break; } case 'P' : { 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 " "plus de deux fois\n"); } else { printf("+++Error : more than two -P " "on command line"); } return(EXIT_FAILURE); } option_P++; break; } case 's' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -s " "on command line"); } return(EXIT_FAILURE); } option_s = d_vrai; drapeau_encart = 'N'; break; } case 'S' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -S " "on command line"); } return(EXIT_FAILURE); } 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 " "incompatibles\n"); } else { printf("+++Error : incompatible options -S " "and -i\n"); } return(EXIT_FAILURE); } option_S = d_vrai; while(*(++argv[0]) == ' '); argv[0]--; if ((*(++argv[0])) != '\0') { if (((*s_etat_processus).definitions_chainees = malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); sem_destroy3((*s_etat_processus) .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = (*s_etat_processus).definitions_chainees; while(*(argv[0]) != '\0') { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; argv[0]--; presence_definition = 'O'; } else if ((--argc) > 0) { argv++; if (((*s_etat_processus).definitions_chainees = malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus) .semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus) .semaphore_fork); sem_destroy3((*s_etat_processus) .semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = (*s_etat_processus).definitions_chainees; while(*(argv[0]) != '\0') { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; argv[0]--; presence_definition = 'O'; } 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 " "spécifié après l'option -S\n"); } else { printf("+++Error : Script required after " "-S option\n"); } return(EXIT_FAILURE); } if (((*s_etat_processus).definitions_chainees = compactage((*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 " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } (*s_etat_processus).longueur_definitions_chainees = (integer8) strlen((*s_etat_processus) .definitions_chainees); break; } case 't' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -t " "on command line"); } return(EXIT_FAILURE); } option_t = d_vrai; (*s_etat_processus).debug = d_vrai; while(*(++argv[0]) == ' '); argv[0]--; if ((*(++argv[0])) != '\0') { 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 " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = type_debug; while((*(argv[0]) != '\0') && (*(argv[0]) != ' ')) { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; argv[0]--; } else if ((--argc) > 0) { argv++; 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 " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } ptr = type_debug; while(*(argv[0]) != '\0') { *(ptr++) = *(argv[0]++); } (*ptr) = '\0'; argv[0]--; } 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 " "de débogage spécifié après " "l'option -t\n"); } else { printf("+++Error : Debug level not " "specified after -t option\n"); } return(EXIT_FAILURE); } ptr = type_debug; while(*ptr != '\0') { switch(*ptr) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': { break; } 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 " "de débogage non " "hexadécimal\n"); } else { printf("+++Error : Debug level must" " be hexadecimal " "integer\n"); } return(EXIT_FAILURE); } } ptr++; } 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 " "de débogage non entier\n"); } else { printf("+++Error : Debug level must" " be integer\n"); } return(EXIT_FAILURE); } free(type_debug); break; } case 'v' : { 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 " "plus d'une fois\n"); } else { printf("+++Error : more than one -v " "on command line"); } return(EXIT_FAILURE); } option_v = d_vrai; printf("\n"); if ((*s_etat_processus).langue == 'F') { printf(" Reverse Polish Lisp/2 version %s " "pour systèmes " "POSIX\n", d_version_rpl); printf(" Langage procédural de très haut " "niveau, semi-compilé, " "extensible,\n"); printf(" destiné principalement aux " "calculs scientifiques et " "symboliques\n"); printf("%s\n", copyright); } else { printf(" Reverse Polish Lisp/2 version %s " "for POSIX operating systems\n", d_version_rpl); printf(" Half-compiled, high-level " "procedural language,\n"); printf(" mainly aiming at scientific " "calculations\n"); printf("%s\n", copyright_anglais); } printf("\n"); break; } case '-': case ' ': { break; } default : { if ((*s_etat_processus).langue == 'F') { printf("+++Information : Option -%c inconnue\n", option); } else { printf("+++Warning : -%c option unknown\n", option); } informations(s_etat_processus); break; } } } } else { if (presence_definition == 'O') { argc = 0; if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Plusieurs définitions\n"); } else { printf("+++Error : More than one definition\n"); } erreur = d_erreur; } else { (*s_etat_processus).nom_fichier_source = argv[0]; presence_definition = 'O'; } } } /* * 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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGSEGV); attente.tv_sec = 0; attente.tv_nsec = 1000000; for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) { nanosleep(&attente, NULL); } if (signal_test != SIGSEGV) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } # endif action.sa_handler = interruption3; action.sa_flags = 0; if (sigaction(SIGBUS, &action, NULL) != 0) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif # ifdef HAVE_SIGSEGV_RECOVERY if (debug == d_faux) { sigsegv_deinstall_handler(); } # endif if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } signal_test = SIGTEST; raise(SIGBUS); attente.tv_sec = 0; attente.tv_nsec = 1000000; for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) { nanosleep(&attente, NULL); } if (signal_test != SIGBUS) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus) .semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif liberation_contexte_cas(s_etat_processus); destruction_queue_signaux(s_etat_processus); # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif # ifdef HAVE_SIGSEGV_RECOVERY if (debug == d_faux) { sigsegv_deinstall_handler(); } # endif erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } } if (option_n == d_vrai) { 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 " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } } if (mode_interactif == d_vrai) { printf("\n"); if ((*s_etat_processus).langue == 'F') { printf("+++Ce logiciel est un logiciel libre" " sans aucune garantie de " "fonctionnement.\n"); printf("+++Pour plus de détails, utilisez la " "commande 'warranty'.\n"); } else { printf("+++This is a free software with " "absolutely no warranty.\n"); printf("+++For details, type 'warranty'.\n"); } printf("\n"); traitement_fichier_temporaire = 'Y'; if ((nom_fichier_temporaire = 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"); } else { printf("+++System : File unavailable\n"); } return(EXIT_FAILURE); } 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"); } else { printf("+++System : File not found\n"); } return(EXIT_FAILURE); } 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"); } else { printf("+++System : Cannot write in file\n"); } return(EXIT_FAILURE); } 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"); } else { printf("+++System : Cannot write in file\n"); } return(EXIT_FAILURE); } 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"); } else { printf("+++System : File unavailable\n"); } return(EXIT_FAILURE); } (*s_etat_processus).lancement_interactif = d_vrai; (*s_etat_processus).nom_fichier_source = nom_fichier_temporaire; presence_definition = 'O'; } else { nom_fichier_temporaire = NULL; } if ((*s_etat_processus).nom_fichier_source == NULL) { erreur_fichier = d_erreur; } else { erreur_fichier = caracteristiques_fichier(s_etat_processus, (*s_etat_processus).nom_fichier_source, &existence, &ouverture, &unite_fichier); } 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') { printf("+++Erreur : Fichier %s inexistant\n", (*s_etat_processus).nom_fichier_source); } else { printf("+++Error : File %s not found\n", (*s_etat_processus).nom_fichier_source); } erreur = d_erreur; } else { if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Absence de définition à exécuter\n"); } else { printf("+++Error : Any executable definition\n"); } } return(EXIT_FAILURE); } 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"); } else { printf("+++System : Null temporary files path\n"); } return(EXIT_FAILURE); } if ((*s_etat_processus).debug == d_vrai) { if ((*s_etat_processus).langue == 'F') { printf("[%d] Chemin des fichiers temporaires %s\n\n", (int) getpid(), (*s_etat_processus).chemin_fichiers_temporaires); } else { printf("[%d] Temporary files path %s\n\n", (int) getpid(), (*s_etat_processus).chemin_fichiers_temporaires); } } if ((erreur == d_absence_erreur) && (presence_definition == 'O')) { (*s_etat_processus).profilage = (option_P != 0) ? d_vrai : d_faux; (*s_etat_processus).niveau_profilage = option_P; (*s_etat_processus).pile_profilage = NULL; (*s_etat_processus).pile_profilage_fonctions = NULL; gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL); (*s_etat_processus).liste_mutexes = NULL; (*s_etat_processus).sections_critiques = 0; (*s_etat_processus).initialisation_scheduler = d_faux; (*s_etat_processus).test_instruction = 'N'; (*s_etat_processus).nombre_arguments = 0; (*s_etat_processus).affichage_arguments = 'N'; (*s_etat_processus).autorisation_conversion_chaine = 'Y'; (*s_etat_processus).autorisation_evaluation_nom = 'Y'; if (mode_interactif == d_vrai) { (*s_etat_processus).autorisation_nom_implicite = 'Y'; } else { (*s_etat_processus).autorisation_nom_implicite = 'N'; } (*s_etat_processus).autorisation_empilement_programme = 'N'; (*s_etat_processus).requete_arret = 'N'; (*s_etat_processus).evaluation_forcee = 'N'; (*s_etat_processus).recherche_type = 'N'; (*s_etat_processus).constante_symbolique = 'N'; (*s_etat_processus).traitement_symbolique = 'N'; (*s_etat_processus).expression_courante = NULL; (*s_etat_processus).objet_courant = NULL; (*s_etat_processus).evaluation_expression_compilee = 'N'; (*s_etat_processus).l_base_pile = NULL; (*s_etat_processus).l_base_pile_last = 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_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).s_bibliotheques = NULL; (*s_etat_processus).s_instructions_externes = NULL; (*s_etat_processus).nombre_instructions_externes = 0; (*s_etat_processus).systeme_axes = 0; (*s_etat_processus).x_min = -10.; (*s_etat_processus).x_max = 10.; (*s_etat_processus).y_min = -10.; (*s_etat_processus).y_max = 10.; (*s_etat_processus).z_min = -10.; (*s_etat_processus).z_max = 10.; (*s_etat_processus).x2_min = -10.; (*s_etat_processus).x2_max = 10.; (*s_etat_processus).y2_min = -10.; (*s_etat_processus).y2_max = 10.; (*s_etat_processus).z2_min = -10.; (*s_etat_processus).z2_max = 10.; (*s_etat_processus).resolution = .01; (*s_etat_processus).souris_active = d_faux; (*s_etat_processus).echelle_automatique_x = d_faux; (*s_etat_processus).echelle_automatique_y = d_faux; (*s_etat_processus).echelle_automatique_z = d_faux; (*s_etat_processus).echelle_automatique_x2 = d_faux; (*s_etat_processus).echelle_automatique_y2 = d_faux; (*s_etat_processus).echelle_automatique_z2 = d_faux; (*s_etat_processus).echelle_log_x = d_faux; (*s_etat_processus).echelle_log_y = d_faux; (*s_etat_processus).echelle_log_z = d_faux; (*s_etat_processus).echelle_log_x2 = d_faux; (*s_etat_processus).echelle_log_y2 = d_faux; (*s_etat_processus).echelle_log_z2 = d_faux; (*s_etat_processus).point_de_vue_theta = 4 * atan((real8) 1) / 6; (*s_etat_processus).point_de_vue_phi = 4 * atan((real8) 1) / 3; (*s_etat_processus).echelle_3D = 1; strcpy((*s_etat_processus).type_trace_eq, "FONCTION"); strcpy((*s_etat_processus).type_trace_sigma, "POINTS"); (*s_etat_processus).fichiers_graphiques = NULL; (*s_etat_processus).nom_fichier_impression = NULL; strcpy((*s_etat_processus).format_papier, "a4paper"); (*s_etat_processus).entree_standard = NULL; (*s_etat_processus).s_marques = NULL; (*s_etat_processus).requete_nouveau_plan = d_vrai; (*s_etat_processus).mise_a_jour_trace_requise = d_faux; (*s_etat_processus).l_base_pile = NULL; (*s_etat_processus).hauteur_pile_operationnelle = 0; (*s_etat_processus).l_base_pile_contextes = NULL; (*s_etat_processus).l_base_pile_taille_contextes = NULL; (*s_etat_processus).position_courante = 0; (*s_etat_processus).l_base_pile_systeme = NULL; (*s_etat_processus).hauteur_pile_systeme = 0; (*s_etat_processus).l_base_pile_processus = NULL; (*s_etat_processus).presence_pipes = d_faux; (*s_etat_processus).pipe_donnees = 0; (*s_etat_processus).pipe_acquittement = 0; (*s_etat_processus).pipe_injections = 0; (*s_etat_processus).pipe_nombre_injections = 0; (*s_etat_processus).nombre_objets_injectes = 0; (*s_etat_processus).nombre_objets_envoyes_non_lus = 0; (*s_etat_processus).pourcentage_maximal_cpu = 100; (*s_etat_processus).temps_maximal_cpu = 0; (*s_etat_processus).thread_fusible = 0; (*s_etat_processus).presence_fusible = d_faux; (*s_etat_processus).niveau_recursivite = 0; (*s_etat_processus).generateur_aleatoire = NULL; (*s_etat_processus).type_generateur_aleatoire = NULL; (*s_etat_processus).colonne_statistique_1 = 1; (*s_etat_processus).colonne_statistique_2 = 2; (*s_etat_processus).debug_programme = d_faux; (*s_etat_processus).execution_pas_suivant = d_faux; (*s_etat_processus).traitement_instruction_halt = d_faux; (*s_etat_processus).derniere_exception = d_ep; (*s_etat_processus).derniere_erreur_systeme = d_es; (*s_etat_processus).derniere_erreur_execution = d_ex; (*s_etat_processus).derniere_erreur_evaluation = d_ex; (*s_etat_processus).derniere_erreur_fonction_externe = 0; (*s_etat_processus).erreur_processus_fils = d_faux; (*s_etat_processus).erreur_systeme_processus_fils = d_es; (*s_etat_processus).erreur_execution_processus_fils = d_ex; (*s_etat_processus).pid_erreur_processus_fils = 0; (*s_etat_processus).exception_processus_fils = d_ep; (*s_etat_processus).core = core; (*s_etat_processus).invalidation_message_erreur = d_faux; (*s_etat_processus).s_objet_errone = NULL; (*s_etat_processus).s_objet_erreur = NULL; (*s_etat_processus).retour_routine_evaluation = 'N'; (*s_etat_processus).traitement_interruption = 'N'; (*s_etat_processus).traitement_interruptible = 'Y'; (*s_etat_processus).nombre_interruptions_en_queue = 0; (*s_etat_processus).nombre_interruptions_non_affectees = 0; for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) { (*s_etat_processus).masque_interruptions[i] = 'N'; (*s_etat_processus).queue_interruptions[i] = 0; (*s_etat_processus).corps_interruptions[i] = NULL; (*s_etat_processus).pile_origine_interruptions[i] = NULL; } (*s_etat_processus).at_exit = NULL; (*s_etat_processus).at_poke = NULL; (*s_etat_processus).traitement_at_poke = 'N'; (*s_etat_processus).pointeurs_caracteres = NULL; (*s_etat_processus).arbre_instructions = NULL; (*s_etat_processus).tid_processus_pere = pthread_self(); (*s_etat_processus).tid = pthread_self(); (*s_etat_processus).pid_processus_pere = getpid(); (*s_etat_processus).processus_detache = d_vrai; (*s_etat_processus).var_volatile_processus_pere = -1; (*s_etat_processus).var_volatile_processus_racine = -1; (*s_etat_processus).var_volatile_traitement_retarde_stop = 0; (*s_etat_processus).var_volatile_alarme = 0; (*s_etat_processus).var_volatile_requete_arret = 0; (*s_etat_processus).var_volatile_requete_arret2 = 0; (*s_etat_processus).var_volatile_traitement_retarde_stop = 0; (*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"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } if (((*s_etat_processus).instruction_derniere_erreur = 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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } strcpy((*s_etat_processus).instruction_derniere_erreur, ""); (*s_etat_processus).niveau_derniere_erreur = 0; if (traitement_fichier_temporaire == 'Y') { (*s_etat_processus).mode_interactif = 'Y'; } else { (*s_etat_processus).mode_interactif = 'N'; } 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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } (*s_etat_processus).instruction_courante[0] = d_code_fin_chaine; empilement_pile_systeme(s_etat_processus); free((*s_etat_processus).instruction_courante); if ((*s_etat_processus).erreur_systeme != d_es) { erreur = d_es_allocation_memoire; } else { (*((*s_etat_processus).l_base_pile_systeme)) .retour_definition = 'Y'; (*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 = allocation(s_etat_processus, NON); if (((*s_etat_processus).indep != NULL) && ((*s_etat_processus).depend != NULL) && ((*s_etat_processus).parametres_courbes_de_niveau != NULL)) { (*((*s_etat_processus).indep)).type = NOM; (*((*s_etat_processus).depend)).type = NOM; (*((*s_etat_processus). parametres_courbes_de_niveau)).type = LST; initialisation_objet((*s_etat_processus).indep); initialisation_objet((*s_etat_processus).depend); initialisation_objet((*s_etat_processus) .parametres_courbes_de_niveau); (*((*s_etat_processus).indep)).objet = (struct_nom *) malloc(sizeof(struct_nom)); (*((*s_etat_processus).depend)).objet = (struct_nom *) malloc(sizeof(struct_nom)); (*((*s_etat_processus).parametres_courbes_de_niveau)) .objet = (struct_liste_chainee *) malloc(sizeof(struct_liste_chainee)); if (((*((*s_etat_processus).depend)).objet == NULL) || ((*((*s_etat_processus).depend)).objet == NULL) || ((*((*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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } (*((struct_nom *) (*((*s_etat_processus).indep)).objet)) .nom = malloc(2 * sizeof(unsigned char)); (*((struct_nom *) (*((*s_etat_processus).depend)).objet)) .nom = malloc(2 * sizeof(unsigned char)); if (((*((struct_nom *) (*((*s_etat_processus).indep)) .objet)).nom == NULL) || ((*((struct_nom *) (*((*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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } strcpy((*((struct_nom *) (*((*s_etat_processus).indep)) .objet)).nom, "X"); strcpy((*((struct_nom *) (*((*s_etat_processus).depend)) .objet)).nom, "Y"); (*((struct_nom *) (*((*s_etat_processus).indep)) .objet)).symbole = d_vrai; (*((struct_nom *) (*((*s_etat_processus).depend)) .objet)).symbole = d_vrai; (*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)).objet)).suivant = NULL; (*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)).objet)).donnee = malloc(sizeof(struct_objet)); (*s_etat_processus).legende = malloc(sizeof(unsigned char)); (*s_etat_processus).label_x = malloc(sizeof(unsigned char)); (*s_etat_processus).label_y = malloc(sizeof(unsigned char)); (*s_etat_processus).label_z = malloc(sizeof(unsigned char)); (*s_etat_processus).titre = malloc(sizeof(unsigned char)); if (((*s_etat_processus).label_x == NULL) || ((*s_etat_processus).label_y == NULL) || ((*s_etat_processus).label_z == NULL) || ((*s_etat_processus).titre == NULL) || ((*s_etat_processus).legende == NULL) || ((*((struct_liste_chainee *) (*((*s_etat_processus) .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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } (*(*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)).objet)).donnee) .type = CHN; initialisation_objet((*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)) .objet)).donnee); if (((*(*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)).objet)).donnee) .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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } strcpy((unsigned char *) (*(*((struct_liste_chainee *) (*((*s_etat_processus) .parametres_courbes_de_niveau)) .objet)).donnee).objet, "AUTOMATIC"); (*s_etat_processus).label_x[0] = d_code_fin_chaine; (*s_etat_processus).label_y[0] = d_code_fin_chaine; (*s_etat_processus).label_z[0] = d_code_fin_chaine; (*s_etat_processus).titre[0] = d_code_fin_chaine; (*s_etat_processus).legende[0] = d_code_fin_chaine; (*s_etat_processus).nom_fichier_gnuplot = NULL; (*s_etat_processus).type_fichier_gnuplot = NULL; (*s_etat_processus).x_tics = 0; (*s_etat_processus).y_tics = 0; (*s_etat_processus).z_tics = 0; (*s_etat_processus).x_lines = d_vrai; (*s_etat_processus).y_lines = d_vrai; (*s_etat_processus).z_lines = d_vrai; (*s_etat_processus).mx_tics = -1; (*s_etat_processus).my_tics = -1; (*s_etat_processus).mz_tics = -1; (*s_etat_processus).mx_lines = d_faux; (*s_etat_processus).my_lines = d_faux; (*s_etat_processus).mz_lines = d_faux; (*s_etat_processus).x2_tics = -1; (*s_etat_processus).y2_tics = -1; (*s_etat_processus).z2_tics = -1; (*s_etat_processus).x2_lines = d_faux; (*s_etat_processus).y2_lines = d_faux; (*s_etat_processus).z2_lines = d_faux; (*s_etat_processus).mx2_tics = -1; (*s_etat_processus).my2_tics = -1; (*s_etat_processus).mz2_tics = -1; (*s_etat_processus).mx2_lines = d_faux; (*s_etat_processus).my2_lines = d_faux; (*s_etat_processus).mz2_lines = d_faux; (*s_etat_processus).mode_evaluation_expression = 'N'; (*s_etat_processus).mode_execution_programme = 'Y'; if ((*s_etat_processus).definitions_chainees == NULL) { 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 :" " Chaînage des définitions" " impossible\n"); } else { printf("+++Fatal : Error in " "compilation\n"); } if (traitement_fichier_temporaire == 'Y') { if (destruction_fichier( nom_fichier_temporaire) == d_erreur) { return(EXIT_FAILURE); } free(nom_fichier_temporaire); } return(EXIT_FAILURE); } } 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) == d_erreur) { return(EXIT_FAILURE); } free(nom_fichier_temporaire); } 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 fichier " "rpl-core [%d]\n", (int) getpid()); } else { printf("+++Information : Writing rpl-core " "file [%d]\n", (int) getpid()); } rplcore(s_etat_processus); if ((*s_etat_processus).langue == 'F') { printf("+++Information : Processus tracé " "[%d]\n", (int) getpid()); } else { printf("+++Information : Done [%d]\n", (int) getpid()); } printf("\n"); } return(EXIT_FAILURE); } (*s_etat_processus).position_courante = 0; (*s_etat_processus).traitement_cycle_exit = 'N'; 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"); } else { printf("+++Fatal : Any entry point\n"); } if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } return(EXIT_FAILURE); } 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"); } else { printf("+++Fatal : Any entry point\n"); } if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } return(EXIT_FAILURE); } if (recherche_variable(s_etat_processus, (*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"); } else { printf("+++Fatal : Any entry point\n"); } if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } return(EXIT_FAILURE); } 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"); } else { printf("+++Fatal : Any entry point\n"); } if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } return(EXIT_FAILURE); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).position_courante = 0; if (((*s_etat_processus).nom_fichier_historique = malloc((strlen(home) + 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') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } sprintf((*s_etat_processus).nom_fichier_historique, "%s/%s", 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); gsl_set_error_handler(&traitement_exceptions_gsl); if (drapeau_encart == 'Y') { (*s_etat_processus).erreur_systeme = d_es; encart(s_etat_processus, (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') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } printf("%s [%d]\n", message, (int) getpid()); free(message); return(EXIT_FAILURE); } } fflush(stdout); if (arguments != NULL) { tampon = (*s_etat_processus).definitions_chainees; (*s_etat_processus).definitions_chainees = arguments; if (analyse_syntaxique(s_etat_processus) == d_erreur) { 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') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } 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 " "syntaxe\n"); } else { printf("+++Error : Syntax error\n"); } return(EXIT_FAILURE); } } (*s_etat_processus).instruction_courante = arguments; (*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) { erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } printf("%s [%d]\n", message, (int) getpid()); free(message); return(EXIT_FAILURE); } if ((*s_etat_processus).erreur_execution != d_ex) { 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') { printf("+++Erreur : Mémoire " "insuffisante\n"); } else { printf("+++Error : Not enough " "memory\n"); } return(EXIT_FAILURE); } 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); } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { 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') { printf("+++Erreur : Mémoire " "insuffisante\n"); } else { printf("+++Error : Not enough " "memory\n"); } return(EXIT_FAILURE); } 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) { 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') { printf("+++Système : Mémoire " "insuffisante\n"); } else { printf("+++System : Not enough " "memory\n"); } return(EXIT_FAILURE); } 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 erreur = d_es_allocation_memoire; return(EXIT_FAILURE); } if ((*s_etat_processus).erreur_execution != d_ex) { 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') { printf("+++Erreur : Mémoire " "insuffisante\n"); } else { printf("+++Error : Not enough " "memory\n"); } return(EXIT_FAILURE); } 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); } } (*s_etat_processus).instruction_courante = NULL; liberation(s_etat_processus, s_objet); free(arguments); } if (option_a == d_vrai) { fprintf(stdout, "%s\n", (*s_etat_processus) .definitions_chainees); } else { if (option_D == d_vrai) { lancement_daemon(s_etat_processus); } if (option_p == d_faux) { 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 { if (setjmp(contexte_initial) == 0) { erreur = sequenceur_optimise(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); } } } } } } } 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); } l_element_courant = (*s_etat_processus).liste_mutexes; while(l_element_courant != NULL) { liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; free((struct_liste_chainee *) l_element_courant); l_element_courant = l_element_suivant; } /* * Arrêt des processus fils */ if ((*s_etat_processus).presence_fusible == d_vrai) { pthread_cancel((*s_etat_processus).thread_fusible); } pthread_mutex_lock(&((*s_etat_processus) .mutex_pile_processus)); l_element_courant = (void *) (*s_etat_processus) .l_base_pile_processus; while(l_element_courant != NULL) { if ((*s_etat_processus).debug == d_vrai) { if (((*s_etat_processus).type_debug & d_debug_processus) != 0) { if ((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread) .processus_detache == d_vrai) { if ((*s_etat_processus).langue == 'F') { printf("[%d] Signalement pour arrêt du " "processus %d\n", (int) getpid(), (int) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).pid); } else { printf("[%d] Send stop signal to " "process %d\n", (int) getpid(), (int) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).pid); } } else { if ((*s_etat_processus).langue == 'F') { printf("[%d] Signalement pour arrêt du " "thread %llu\n", (int) getpid(), (unsigned long long) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid); } else { printf("[%d] Send stop signal to " "thread %llu\n", (int) getpid(), (unsigned long long) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid); } } } } if ((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).processus_detache == d_vrai) { if ((*s_etat_processus).var_volatile_alarme != 0) { envoi_signal_processus( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).pid, rpl_sigurg); } else { 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 { pthread_mutex_lock(&((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).thread) .mutex)); if ((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).thread) .thread_actif == d_vrai) { if ((*s_etat_processus).var_volatile_alarme != 0) { envoi_signal_thread( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).tid, rpl_sigurg); } else { 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); } } } pthread_mutex_unlock( &((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).thread) .mutex)); } l_element_courant = (*((struct_liste_chainee *) l_element_courant)).suivant; } /* * Attente de la fin de tous les processus fils */ for(i = 0; i < d_NOMBRE_INTERRUPTIONS; (*s_etat_processus).masque_interruptions[i++] = 'I'); attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; while((*s_etat_processus).l_base_pile_processus != NULL) { l_element_courant = (void *) (*s_etat_processus).l_base_pile_processus; for(i = 0; i < (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).thread) .nombre_objets_dans_pipe; i++) { if ((s_objet = lecture_pipe( s_etat_processus, (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).thread) .pipe_objets[0])) != NULL) { liberation(s_etat_processus, s_objet); (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).nombre_objets_dans_pipe--; action.sa_handler = SIG_IGN; action.sa_flags = 0; if (sigaction(SIGPIPE, &action, ®istre) != 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 pthread_mutex_unlock(&((*s_etat_processus) .mutex_pile_processus)); return(EXIT_FAILURE); } while((longueur_ecriture = write_atomic(s_etat_processus, (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).pipe_nombre_injections[1], "+", sizeof(unsigned char))) != sizeof(unsigned char)) { if (longueur_ecriture == -1) { // Le processus n'existe plus. break; } } if (sigaction(SIGPIPE, ®istre, 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 pthread_mutex_unlock(&((*s_etat_processus) .mutex_pile_processus)); return(EXIT_FAILURE); } } } 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); scrutation_interruptions(s_etat_processus); pthread_mutex_lock(&((*s_etat_processus) .mutex_pile_processus)); } pthread_mutex_unlock(&((*s_etat_processus) .mutex_pile_processus)); erreur_historique = write_history( (*s_etat_processus).nom_fichier_historique); clear_history(); if (erreur_historique != 0) { if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : L'historique ne peut être " "écrit\n"); } else { printf("+++Error : History cannot be " "written\n"); } if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } } free((*s_etat_processus).nom_fichier_historique); if (((*s_etat_processus).core == d_vrai) && (erreur == d_erreur) && ((*s_etat_processus).var_volatile_traitement_sigint == 0)) { printf("\n"); if ((*s_etat_processus).langue == 'F') { printf("+++Information : Génération du fichier " "rpl-core [%d]\n", (int) getpid()); } else { printf("+++Information : Writing rpl-core " "file [%d]\n", (int) getpid()); } rplcore(s_etat_processus); if ((*s_etat_processus).langue == 'F') { printf("+++Information : Processus tracé [%d]\n", (int) getpid()); } else { printf("+++Information : Done [%d]\n", (int) getpid()); } printf("\n"); } free((*s_etat_processus).definitions_chainees); /* * Libération de l'arbre des instructions */ liberation_arbre_instructions(s_etat_processus, (*s_etat_processus).arbre_instructions); free((*s_etat_processus).pointeurs_caracteres); if ((*s_etat_processus).entree_standard != NULL) { pclose((*s_etat_processus).entree_standard); (*s_etat_processus).entree_standard = NULL; } if ((*s_etat_processus).nom_fichier_impression != NULL) { if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Queue d'impression " "non vide !\n"); } else { printf("+++Warning : Non empty printing " "spool queue !\n"); } instruction_erase(s_etat_processus); } if ((*s_etat_processus).fichiers_graphiques != NULL) { instruction_cllcd(s_etat_processus); } liberation(s_etat_processus, (*s_etat_processus).indep); liberation(s_etat_processus, (*s_etat_processus).depend); free((*s_etat_processus).label_x); free((*s_etat_processus).label_y); free((*s_etat_processus).label_z); free((*s_etat_processus).titre); free((*s_etat_processus).legende); liberation(s_etat_processus, (*s_etat_processus) .parametres_courbes_de_niveau); for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) { liberation(s_etat_processus, (*s_etat_processus).corps_interruptions[i]); l_element_courant = (*s_etat_processus) .pile_origine_interruptions[i]; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free(l_element_courant); l_element_courant = l_element_suivant; } } if ((*s_etat_processus).instruction_derniere_erreur != NULL) { free((*s_etat_processus).instruction_derniere_erreur); (*s_etat_processus).instruction_derniere_erreur = NULL; } /* * Le pointeur s_etat_processus.nom_fichier_source est * alloué par le système. Il ne faut donc pas * le libérer... */ 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); l_element_statique_courant = (*s_etat_processus) .l_liste_variables_statiques; while(l_element_statique_courant != NULL) { l_element_statique_suivant = (*l_element_statique_courant).suivant; free(l_element_statique_courant); l_element_statique_courant = l_element_statique_suivant; } l_element_partage_courant = (*(*s_etat_processus) .l_liste_variables_partagees); while(l_element_partage_courant != NULL) { l_element_partage_suivant = (*l_element_partage_courant).suivant; free(l_element_partage_courant); l_element_partage_courant = l_element_partage_suivant; } /* * Si resultats est non nul, rplinit a été appelé * depuis rpl() [librpl] et non main(). * On copie alors le contenu de la * pile dans un * tableau **resultats dont le pointeur de base a * été alloué dans rpl(). */ if (resultats != NULL) { if ((*resultats) != NULL) { free((*resultats)); if (((*resultats) = malloc(((size_t) ((*s_etat_processus) .hauteur_pile_operationnelle + 1)) * sizeof(unsigned char **))) != NULL) { (*resultats)[(*s_etat_processus) .hauteur_pile_operationnelle] = NULL; l_element_courant = (void *) (*s_etat_processus) .l_base_pile; for(i = 0; i < (*s_etat_processus) .hauteur_pile_operationnelle; i++) { if (l_element_courant != NULL) { (*resultats)[i] = formateur(s_etat_processus, 0, (*((struct_liste_chainee *) l_element_courant)).donnee); if ((*resultats)[i] == NULL) { i = (*s_etat_processus). hauteur_pile_operationnelle; } else { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; } } } } else { (*resultats) = NULL; erreur = d_es_allocation_memoire; } } } l_element_courant = (void *) (*s_etat_processus) .l_base_pile; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free((struct_liste_chainee *) l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus) .l_base_pile_contextes; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free((struct_liste_chainee *) l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus) .l_base_pile_taille_contextes; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free((struct_liste_chainee *) l_element_courant); l_element_courant = l_element_suivant; } for(i = 0; i < (*s_etat_processus) .nombre_instructions_externes; i++) { free((*s_etat_processus).s_instructions_externes[i] .nom); free((*s_etat_processus).s_instructions_externes[i] .nom_bibliotheque); } if ((*s_etat_processus).nombre_instructions_externes != 0) { free((*s_etat_processus).s_instructions_externes); } l_element_courant = (void *) (*s_etat_processus) .s_bibliotheques; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; free((*((struct_bibliotheque *) (*((struct_liste_chainee *) l_element_courant)).donnee)).nom); dlclose((*((struct_bibliotheque *) (*((struct_liste_chainee *) l_element_courant)).donnee)).descripteur); free((*((struct_liste_chainee *) l_element_courant)) .donnee); free(l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus) .l_base_pile_last; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free((struct_liste_chainee *) l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus) .l_base_pile_systeme; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_pile_systeme *) l_element_courant)).suivant; liberation(s_etat_processus, (*((struct_liste_pile_systeme *) l_element_courant)).indice_boucle); liberation(s_etat_processus, (*((struct_liste_pile_systeme *) l_element_courant)).limite_indice_boucle); liberation(s_etat_processus, (*((struct_liste_pile_systeme *) l_element_courant)).objet_de_test); if ((*((struct_liste_pile_systeme *) l_element_courant)).nom_variable != NULL) { free((*((struct_liste_pile_systeme *) l_element_courant)).nom_variable); } free((struct_liste_pile_systeme *) l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus).s_fichiers; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; fclose((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)) .descripteur_c); if ((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)).type != 'C') { sqlite3_close((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)) .descripteur_sqlite); } if ((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)) .effacement == 'Y') { unlink((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)) .nom); } free((*((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee)).nom); free((struct_descripteur_fichier *) (*((struct_liste_chainee *) l_element_courant)).donnee); free(l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus).s_sockets; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; if ((*((struct_socket *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .socket_connectee == d_vrai) { shutdown((*((struct_socket *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .socket, SHUT_RDWR); } close((*((struct_socket *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).socket); if ((*((struct_socket *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).effacement == 'Y') { unlink((*((struct_socket *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .adresse); } liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free(l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (void *) (*s_etat_processus).s_connecteurs_sql; while(l_element_courant != NULL) { l_element_suivant = (*((struct_liste_chainee *) l_element_courant)).suivant; sqlclose((*((struct_liste_chainee *) l_element_courant)).donnee); liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); free(l_element_courant); l_element_courant = l_element_suivant; } l_element_courant = (*s_etat_processus).s_marques; while(l_element_courant != NULL) { free((*((struct_marque *) l_element_courant)).label); free((*((struct_marque *) l_element_courant)).position); l_element_suivant = (*((struct_marque *) l_element_courant)).suivant; free(l_element_courant); l_element_courant = l_element_suivant; } } else { erreur = d_es_allocation_memoire; if (test_cfsf(s_etat_processus, 51) == d_faux) { printf("%s", ds_beep); } if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } } } liberation_allocateur(s_etat_processus); } if (traitement_fichier_temporaire == 'Y') { destruction_fichier(nom_fichier_temporaire); free(nom_fichier_temporaire); } if ((*s_etat_processus).profilage == d_vrai) { ecriture_profil(s_etat_processus); liberation_profil(s_etat_processus); } } closelog(); pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes)); retrait_thread(s_etat_processus); pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus)); pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions)); pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux)); pthread_mutex_destroy(&mutex_sections_critiques); pthread_mutex_destroy(&mutex_liste_variables_partagees); # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), SEM_FORK); # endif free((*s_etat_processus).localisation); 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; } free(arg_exec); arret_thread_signaux(s_etat_processus); liberation_allocateur_buffer(s_etat_processus); free(s_etat_processus); # ifdef DEBUG_MEMOIRE debug_memoire_verification(); analyse_post_mortem(); # endif # ifdef HAVE_STACK_OVERFLOW_RECOVERY stackoverflow_deinstall_handler(); # endif # ifdef HAVE_SIGSEGV_RECOVERY if (debug == d_faux) { sigsegv_deinstall_handler(); } # endif return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE); } void informations(struct_processus *s_etat_processus) { printf("\n"); if ((*s_etat_processus).langue == 'F') { printf(" rpl [-options] [programme]\n"); printf(" -a : analyse du code\n"); printf(" -A : paramètres passés au programme principal\n"); printf(" -c : génération de fichier de débogage (rpl-core)\n"); printf(" -d : option de déverminage interne\n"); printf(" -D : lancement d'un daemon\n"); printf(" -h : aide sur la ligne de commande\n"); printf(" -i : fonctionnement interactif\n"); 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 (-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"); printf(" -v : version\n"); } else { printf(" rpl [-options] [program]\n"); printf(" -a : analyzes program\n"); printf(" -A : sends parameters to main program\n"); printf(" -c : allows creation of a rpl-core file, providing a way" "\n" " to debug a program\n"); printf(" -d : internal debug process\n"); printf(" -D : starts in daemon mode\n"); printf(" -h : shows a summary of available options\n"); printf(" -i : runs the RPL/2 sequencer in interactive mode\n"); printf(" -l : prints the user licence of the software\n"); printf(" -n : ignores HUP signal\n"); printf(" -p : precompiles script\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"); printf(" -v : prints the version number\n"); } printf("\n"); return; } logical1 controle_integrite(struct_processus *s_etat_processus, unsigned char *executable_candidat, unsigned char *executable) { unsigned char *md5; unsigned char *sha1; if (strcmp(executable, "rplpp") == 0) { md5 = rplpp_md5; sha1 = rplpp_sha1; } else if (strcmp(executable, "rplfile") == 0) { md5 = rplfile_md5; sha1 = rplfile_sha1; } else if (strcmp(executable, "rpliconv") == 0) { md5 = rpliconv_md5; sha1 = rpliconv_sha1; } else if (strcmp(executable, "rplawk") == 0) { md5 = rplawk_md5; sha1 = rplawk_sha1; } else if (strcmp(executable, "rplconvert") == 0) { md5 = rplconvert_md5; sha1 = rplconvert_sha1; } else { return(d_faux); } if (controle(s_etat_processus, executable_candidat, "md5", md5) != d_vrai) { return(d_faux); } if (controle(s_etat_processus, executable_candidat, "sha1", sha1) != d_vrai) { return(d_faux); } return(d_vrai); } unsigned char * date_compilation() { unsigned char *date; if ((date = malloc((strlen(d_date_en_rpl) + 1) * sizeof(unsigned char))) == NULL) { return(NULL); } strcpy(date, d_date_en_rpl); return(date); } #pragma GCC diagnostic pop // vim: ts=4