/* ================================================================================ RPL/2 (R) version 4.0.22 Copyright (C) 1989-2011 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" #ifdef IPCS_SYSV #ifndef OS2 unsigned char *chemin_semaphores_SysV; #endif #endif /* ================================================================================ Programme principal ================================================================================ */ int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home) { # include "copyright-conv.h" # include "licence-conv.h" file *f_source; int erreur_historique; int option_P; int status; 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_table_variables_partagees s_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 i; unsigned long unite_fichier; void *l_element_courant; void *l_element_suivant; volatile int erreur; volatile unsigned char traitement_fichier_temporaire; errno = 0; # ifdef DMALLOC atexit(dmalloc_shutdown()); # endif # ifdef DEBUG_MEMOIRE debug_memoire_initialisation(); # endif setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); # ifndef SEMAPHORES_NOMMES sem_init(&semaphore_liste_threads, 0, 1); sem_init(&semaphore_gestionnaires_signaux, 0, 0); sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1); # else semaphore_liste_threads = sem_init2(1, sem_liste_threads); semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux); semaphore_gestionnaires_signaux_atomique = sem_init2(1, sem_gestionnaires_signaux_atomique); if ((semaphore_liste_threads == SEM_FAILED) || (semaphore_gestionnaires_signaux == SEM_FAILED) || (semaphore_gestionnaires_signaux_atomique == SEM_FAILED)) { 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); } # endif 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); } if ((langue = getenv("LANG")) != NULL) { (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0) ? 'F' : 'E'; } else { (*s_etat_processus).langue = 'E'; } (*s_etat_processus).exception = d_ep; (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex; (*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), &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); # ifndef SEMAPHORES_NOMMES sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); # else if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) == SEM_FAILED) { if ((*s_etat_processus).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).s_liste_variables_partagees = &s_variables_partagees; s_variables_partagees.nombre_variables = 0; s_variables_partagees.nombre_variables_allouees = 0; s_variables_partagees.table = NULL; pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees)) .mutex), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); (*s_etat_processus).chemin_fichiers_temporaires = recherche_chemin_fichiers_temporaires(s_etat_processus); # ifdef IPCS_SYSV # ifndef OS2 chemin_semaphores_SysV = (*s_etat_processus).chemin_fichiers_temporaires; # endif # endif # ifdef _BROKEN_SIGINFO creation_fifos_signaux(s_etat_processus); # ifdef return # undef return # endif # define return destruction_fifos_signaux(s_etat_processus); return # endif insertion_thread(s_etat_processus, d_vrai); # ifndef OS2 localisation_courante(s_etat_processus); # else if ((*s_etat_processus).erreur_systeme != d_es) { if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * sizeof(unsigned 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); } strcpy((*s_etat_processus).localisation, d_locale); } # endif (*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) { 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); } 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 à 2010, 2011 BERTRAND Joël\n"); } else { printf("+++Copyright (C) 1989 to 2010, 2011 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 = ""; } // Initialisation d'une clef if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0) { if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } # ifndef SEMAPHORES_NOMMES if (pthread_setspecific(semaphore_fork_processus_courant, &((*s_etat_processus).semaphore_fork)) != 0) # else if (pthread_setspecific(semaphore_fork_processus_courant, (*s_etat_processus).semaphore_fork) != 0) # endif { if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } // Initialisation d'une pile de signal pour récupérer les // débordement de pile # if !defined(Cygwin) && !defined(OpenBSD) if (((*s_etat_processus).pile_signal.ss_sp = malloc((*s_etat_processus).pile_signal.ss_size = SIGSTKSZ)) == NULL) { erreur = d_es_allocation_memoire; 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).pile_signal.ss_flags = 0; if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 0) { erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation de la pile spécifique de signal" " impossible\n"); } else { printf("+++System : Initialization of signal stack failed\n"); } return(EXIT_FAILURE); } # endif # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption1; # else action.sa_handler = interruption1; # endif action.sa_flags = SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGINT, &action, NULL) != 0) { 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) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption2; # else action.sa_handler = interruption2; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGTSTP, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption4; # else action.sa_handler = interruption4; # endif // SIGCONT ne doit pas pouvoir être appelé depuis son gestionnaire. action.sa_flags = SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGSTART, &action, NULL) != 0) { 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(SIGCONT, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption5; # else action.sa_handler = interruption5; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGFSTOP, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption11; # else action.sa_handler = interruption11; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGFABORT, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption8; # else action.sa_handler = interruption8; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGURG, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption7; # else action.sa_handler = interruption7; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGPIPE, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption6; # else action.sa_handler = interruption6; # endif action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER; if (sigaction(SIGINJECT, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption9; # else action.sa_handler = interruption9; # endif action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER; if (sigaction(SIGABORT, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption1; # else action.sa_handler = interruption1; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGALRM, &action, NULL) != 0) { 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); } # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption3; # else action.sa_handler = interruption3; # endif action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; erreur = d_absence_erreur; core = d_faux; 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; while((--argc) > 0) { if ((*(++argv))[0] == '-') { while((option = *(++argv[0])) != '\0') { switch(option) { case 'a' : { if (option_a == d_vrai) { 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) { 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) { 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) { 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 ((*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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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 ((*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) { 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 = strlen((*s_etat_processus) .definitions_chainees); break; } case 't' : { if (option_t == d_vrai) { 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) { 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) { 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 { 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: { 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) { 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) { 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; } 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'; } } } if (debug == d_faux) { if (sigaction(SIGSEGV, &action, NULL) != 0) { 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(SIGBUS, &action, NULL) != 0) { if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " "impossible\n"); } else { printf("+++System : Initialization of POSIX signals " "failed\n"); } return(EXIT_FAILURE); } } if (option_n == d_vrai) { # ifndef _BROKEN_SIGINFO action.sa_sigaction = interruption10; # else action.sa_handler = interruption10; # endif action.sa_flags = SA_ONSTACK | SA_SIGINFO; if (sigaction(SIGHUP, &action, NULL) != 0) { 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) { 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) { 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) { 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) { 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) { 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)) { 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) { 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).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_liste_variables = NULL; (*s_etat_processus).gel_liste_variables = d_faux; (*s_etat_processus).nombre_variables = 0; (*s_etat_processus).nombre_variables_allouees = 0; (*s_etat_processus).s_liste_variables_statiques = NULL; (*s_etat_processus).nombre_variables_statiques = 0; (*s_etat_processus).nombre_variables_statiques_allouees = 0; (*s_etat_processus).niveau_courant = 0; (*s_etat_processus).niveau_initial = 0; (*s_etat_processus).creation_variables_statiques = d_faux; (*s_etat_processus).creation_variables_partagees = d_faux; (*s_etat_processus).position_variable_courante = 0; (*s_etat_processus).position_variable_statique_courante = 0; (*s_etat_processus).s_bibliotheques = NULL; (*s_etat_processus).s_instructions_externes = NULL; (*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).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; initialisation_allocateur(s_etat_processus); initialisation_drapeaux(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } if (((*s_etat_processus).instruction_derniere_erreur = malloc(sizeof(unsigned char))) == 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); } 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) { 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 = (struct_objet *) malloc( sizeof(struct_objet)); (*s_etat_processus).depend = (struct_objet *) malloc( sizeof(struct_objet)); (*s_etat_processus).parametres_courbes_de_niveau = (struct_objet *) malloc(sizeof(struct_objet)); 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)) { 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)) { 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)) { 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) { 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; if ((*s_etat_processus).erreur_systeme != d_es) { if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); } else { printf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } (*s_etat_processus).mode_evaluation_expression = 'N'; (*s_etat_processus).mode_execution_programme = 'Y'; if ((*s_etat_processus).definitions_chainees == NULL) { if ((erreur = chainage(s_etat_processus)) != d_absence_erreur) { 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) { 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).nombre_variables == 0) { 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) { 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) { 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).s_liste_variables [(*s_etat_processus) .position_variable_courante].niveau != 0) { 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) { 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(); 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, (unsigned long) (5 * 1000000)); if ((*s_etat_processus).erreur_systeme != d_es) { 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); } } fflush(stdout); initialisation_instructions(s_etat_processus); 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) { 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 { 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; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { 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) { 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); 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) { 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); return(EXIT_FAILURE); } 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) { 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) { 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); 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); } } else { if (setjmp(contexte_initial) == 0) { erreur = sequenceur_optimise(s_etat_processus); } } if (erreur == d_absence_erreur) { if (((*s_etat_processus).var_volatile_alarme == 0) && ((*s_etat_processus).arret_depuis_abort == 0) && ((*s_etat_processus).at_exit != NULL)) { erreur = evaluation(s_etat_processus, (*s_etat_processus).at_exit, 'E'); } } } 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) { pthread_mutex_trylock(&((*((struct_mutex *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).mutex)); pthread_mutex_unlock(&((*((struct_mutex *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).mutex)); pthread_mutex_destroy(&((*((struct_mutex *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)).mutex)); liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); 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)); 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) { kill((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).pid, SIGURG); } else { if ((*s_etat_processus).arret_depuis_abort == -1) { kill((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).pid, SIGFABORT); } else { kill((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).pid, SIGFSTOP); } } } 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) { pthread_kill((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) .thread).tid, SIGURG); } else { if ((*s_etat_processus).arret_depuis_abort == -1) { pthread_kill( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid, SIGFABORT); } else { pthread_kill( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid, SIGFSTOP); } } } 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) { status = 0; l_element_courant = (void *) (*s_etat_processus).l_base_pile_processus; for(i = 0; i < (unsigned long) (*(*((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 = SA_ONSTACK; if (sigaction(SIGPIPE, &action, ®istre) != 0) { pthread_mutex_unlock( &((*s_etat_processus).mutex)); 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) { pthread_mutex_unlock( &((*s_etat_processus).mutex)); return(EXIT_FAILURE); } } } pthread_mutex_unlock(&((*s_etat_processus).mutex)); if ((*s_etat_processus) .nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles( s_etat_processus); } nanosleep(&attente, NULL); pthread_mutex_lock(&((*s_etat_processus).mutex)); } pthread_mutex_unlock(&((*s_etat_processus).mutex)); 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... */ for(i = 0; i < (*s_etat_processus).nombre_variables; i++) { liberation(s_etat_processus, (*s_etat_processus).s_liste_variables[i].objet); free((*s_etat_processus).s_liste_variables[i].nom); } free((*s_etat_processus).s_liste_variables); for(i = 0; i < (*s_etat_processus) .nombre_variables_statiques; i++) { liberation(s_etat_processus, (*s_etat_processus) .s_liste_variables_statiques[i].objet); free((*s_etat_processus) .s_liste_variables_statiques[i].nom); } free((*s_etat_processus).s_liste_variables_statiques); for(i = 0; i < (*((*s_etat_processus) .s_liste_variables_partagees)).nombre_variables; i++) { liberation(s_etat_processus, (*((*s_etat_processus) .s_liste_variables_partagees)).table[i].objet); free((*((*s_etat_processus) .s_liste_variables_partagees)).table[i].nom); } free((struct_variable_partagee *) (*((*s_etat_processus).s_liste_variables_partagees)) .table); /* * Si resultats est non nul, rplinit a été appelé * depuis rpl() [librpl] et non main(). * 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(((*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') { if (destruction_fichier(nom_fichier_temporaire) == d_erreur) { return(EXIT_FAILURE); } 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)); pthread_mutex_destroy(&((*((*s_etat_processus).s_liste_variables_partagees)) .mutex)); retrait_thread(s_etat_processus); pthread_mutex_destroy(&((*s_etat_processus).mutex)); pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork); # endif free((*s_etat_processus).localisation); # ifndef SEMAPHORES_NOMMES sem_destroy(&semaphore_liste_threads); # else sem_destroy2(semaphore_liste_threads, sem_liste_threads); # endif # ifndef SEMAPHORES_NOMMES sem_post(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux_atomique); # else sem_post(semaphore_gestionnaires_signaux); sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux); sem_destroy2(semaphore_gestionnaires_signaux_atomique, sem_gestionnaires_signaux_atomique); # endif # ifdef _BROKEN_SIGINFO destruction_fifos_signaux(s_etat_processus); # undef return # endif free((*s_etat_processus).chemin_fichiers_temporaires); free(s_etat_processus); # ifdef DEBUG_MEMOIRE debug_memoire_verification(); analyse_post_mortem(); # 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\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\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; } // vim: ts=4