|
version 1.107, 2012/01/05 10:19:05
|
version 1.221, 2023/11/22 10:55:15
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.1.5 |
RPL/2 (R) version 4.1.35 |
| Copyright (C) 1989-2012 Dr. BERTRAND Joël |
Copyright (C) 1989-2023 Dr. BERTRAND Joël |
| |
|
| This file is part of RPL/2. |
This file is part of RPL/2. |
| |
|
|
Line 23
|
Line 23
|
| #define MAIN_RPL |
#define MAIN_RPL |
| #include "rpl-conv.h" |
#include "rpl-conv.h" |
| |
|
| |
// Bug de gcc à partir de gcc 4.6 (bug 48544) |
| |
#pragma GCC diagnostic push |
| |
#pragma GCC diagnostic ignored "-Wclobbered" |
| |
|
| |
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
|
Line 51 rplinit(int argc, char *argv[], char *en
|
Line 55 rplinit(int argc, char *argv[], char *en
|
| int erreur_historique; |
int erreur_historique; |
| int option_P; |
int option_P; |
| |
|
| |
integer8 i; |
| |
|
| logical1 core; |
logical1 core; |
| logical1 debug; |
logical1 debug; |
| logical1 erreur_fichier; |
logical1 erreur_fichier; |
|
Line 80 rplinit(int argc, char *argv[], char *en
|
Line 86 rplinit(int argc, char *argv[], char *en
|
| |
|
| struct_processus *s_etat_processus; |
struct_processus *s_etat_processus; |
| |
|
| struct_table_variables_partagees s_variables_partagees; |
struct_liste_chainee *l_bibliotheques; |
| |
struct_liste_chainee *l_bibliotheque_courante; |
| |
struct_liste_chainee *l_nouvelle_bibliotheque; |
| |
|
| |
struct_liste_variables_partagees *l_element_partage_courant; |
| |
struct_liste_variables_partagees *l_element_partage_suivant; |
| |
|
| |
struct_liste_variables_statiques *l_element_statique_courant; |
| |
struct_liste_variables_statiques *l_element_statique_suivant; |
| |
|
| |
struct_arbre_variables_partagees *s_arbre_variables_partagees; |
| |
struct_liste_variables_partagees *l_liste_variables_partagees; |
| |
|
| struct sigaction action; |
struct sigaction action; |
| struct sigaction registre; |
struct sigaction registre; |
|
Line 99 rplinit(int argc, char *argv[], char *en
|
Line 116 rplinit(int argc, char *argv[], char *en
|
| unsigned char *ptr; |
unsigned char *ptr; |
| unsigned char *tampon; |
unsigned char *tampon; |
| |
|
| unsigned long i; |
|
| unsigned long unite_fichier; |
unsigned long unite_fichier; |
| |
|
| void *l_element_courant; |
void *l_element_courant; |
|
Line 111 rplinit(int argc, char *argv[], char *en
|
Line 127 rplinit(int argc, char *argv[], char *en
|
| errno = 0; |
errno = 0; |
| s_queue_signaux = NULL; |
s_queue_signaux = NULL; |
| routine_recursive = 0; |
routine_recursive = 0; |
| |
nombre_threads_surveillance_processus = 0; |
| pid_processus_pere = getpid(); |
pid_processus_pere = getpid(); |
| |
|
| |
# ifdef DEBUG_PROC |
| |
__proc = 0; |
| |
# endif |
| |
|
| # ifdef DEBUG_MEMOIRE |
# ifdef DEBUG_MEMOIRE |
| debug_memoire_initialisation(); |
debug_memoire_initialisation(); |
| # endif |
# endif |
|
Line 120 rplinit(int argc, char *argv[], char *en
|
Line 141 rplinit(int argc, char *argv[], char *en
|
| setvbuf(stdout, NULL, _IOLBF, 0); |
setvbuf(stdout, NULL, _IOLBF, 0); |
| setvbuf(stderr, NULL, _IOLBF, 0); |
setvbuf(stderr, NULL, _IOLBF, 0); |
| |
|
| # ifndef SEMAPHORES_NOMMES |
if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL) |
| sem_init(&semaphore_gestionnaires_signaux, 0, 0); |
|
| # else |
|
| semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX); |
|
| |
|
| if (semaphore_gestionnaires_signaux == SEM_FAILED) |
|
| { |
{ |
| erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
| |
|
|
Line 147 rplinit(int argc, char *argv[], char *en
|
Line 163 rplinit(int argc, char *argv[], char *en
|
| |
|
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| # endif |
|
| |
|
| if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) |
(*s_etat_processus).erreur_systeme = d_es; |
| |
|
| |
initialisation_allocateur_buffer(s_etat_processus); |
| |
|
| |
if ((*s_etat_processus).erreur_systeme != d_es) |
| |
{ |
| |
erreur = d_es_allocation_memoire; |
| |
|
| |
if ((langue = getenv("LANG")) != NULL) |
| |
{ |
| |
if (strncmp(langue, "fr", 2) == 0) |
| |
{ |
| |
uprintf("+++Système : Mémoire insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
uprintf("+++System : Not enough memory\n"); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
uprintf("+++System : Not enough memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
if (initialisation_etat_processus_readline() != 0) |
| { |
{ |
| erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
| |
|
|
Line 184 rplinit(int argc, char *argv[], char *en
|
Line 226 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) |
if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) |
| { |
{ |
| if ((langue = getenv("LANG")) != NULL) |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| if (strncmp(langue, "fr", 2) == 0) |
uprintf("+++Système : Mémoire insuffisante\n"); |
| { |
|
| uprintf("+++Système : Mémoire insuffisante\n"); |
|
| } |
|
| else |
|
| { |
|
| uprintf("+++System : Not enough memory\n"); |
|
| } |
|
| } |
} |
| else |
else |
| { |
{ |
|
Line 203 rplinit(int argc, char *argv[], char *en
|
Line 238 rplinit(int argc, char *argv[], char *en
|
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
| if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL) |
if ((arg_exec = sys_malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL) |
| { |
{ |
| if ((langue = getenv("LANG")) != NULL) |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| if (strncmp(langue, "fr", 2) == 0) |
uprintf("+++Système : Mémoire insuffisante\n"); |
| { |
|
| uprintf("+++Système : Mémoire insuffisante\n"); |
|
| } |
|
| else |
|
| { |
|
| uprintf("+++System : Not enough memory\n"); |
|
| } |
|
| } |
} |
| else |
else |
| { |
{ |
|
Line 224 rplinit(int argc, char *argv[], char *en
|
Line 252 rplinit(int argc, char *argv[], char *en
|
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
| for(i = 0; i < (unsigned long) argc; i++) |
for(i = 0; i < argc; i++) |
| { |
{ |
| arg_exec[i] = argv[i]; |
arg_exec[i] = argv[i]; |
| } |
} |
| |
|
| argv[argc] = NULL; |
arg_exec[argc] = NULL; |
| |
|
| initialisation_contexte_cas(s_etat_processus); |
initialisation_contexte_cas(s_etat_processus); |
| |
|
|
Line 242 rplinit(int argc, char *argv[], char *en
|
Line 270 rplinit(int argc, char *argv[], char *en
|
| |
|
| pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_init(&attributs_mutex); |
| pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
| pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex); |
pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus), |
| |
&attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
| |
pthread_mutex_init(&((*s_etat_processus).mutex_interruptions), |
| |
&attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
| |
pthread_mutex_init(&((*s_etat_processus).mutex_signaux), |
| |
&attributs_mutex); |
| pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_init(&attributs_mutex); |
|
Line 251 rplinit(int argc, char *argv[], char *en
|
Line 292 rplinit(int argc, char *argv[], char *en
|
| &attributs_mutex); |
&attributs_mutex); |
| pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
| |
pthread_mutex_init(&((*s_etat_processus).mutex_allocation_buffer), |
| |
&attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
| |
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
| |
pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
| |
pthread_mutex_init(&mutex_liste_threads, &attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
| |
pthread_mutex_init(&mutex_liste_threads_surveillance, &attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| |
pthread_mutexattr_init(&attributs_mutex); |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
| |
pthread_mutex_init(&mutex_sigaction, &attributs_mutex); |
| |
pthread_mutexattr_destroy(&attributs_mutex); |
| |
|
| # ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
| sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); |
if (sem_init(&((*s_etat_processus).semaphore_fork), 0, 0) != 0) |
| # else |
# else |
| if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), |
if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), |
| pthread_self(), SEM_FORK)) == SEM_FAILED) |
pthread_self(), SEM_FORK)) == SEM_FAILED) |
| { |
# endif |
| if ((*s_etat_processus).langue == 'F') |
{ |
| { |
liberation_contexte_cas(s_etat_processus); |
| uprintf("+++Système : Mémoire insuffisante\n"); |
|
| } |
|
| else |
|
| { |
|
| uprintf("+++System : Not enough memory\n"); |
|
| } |
|
| |
|
| return(EXIT_FAILURE); |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
uprintf("+++Système : Mémoire insuffisante\n"); |
| } |
} |
| # endif |
else |
| |
{ |
| |
uprintf("+++System : Not enough memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_init(&attributs_mutex); |
| pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
|
Line 276 rplinit(int argc, char *argv[], char *en
|
Line 350 rplinit(int argc, char *argv[], char *en
|
| &attributs_mutex); |
&attributs_mutex); |
| pthread_mutexattr_destroy(&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 = |
(*s_etat_processus).chemin_fichiers_temporaires = |
| recherche_chemin_fichiers_temporaires(s_etat_processus); |
recherche_chemin_fichiers_temporaires(s_etat_processus); |
| |
|
| insertion_thread(s_etat_processus, d_vrai); |
insertion_thread(s_etat_processus, d_vrai); |
| creation_queue_signaux(s_etat_processus); |
creation_queue_signaux(s_etat_processus); |
| |
|
| # ifndef OS2 |
|
| localisation_courante(s_etat_processus); |
|
| # else |
|
| if ((*s_etat_processus).erreur_systeme != d_es) |
if ((*s_etat_processus).erreur_systeme != d_es) |
| { |
{ |
| if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * |
# ifndef SEMAPHORES_NOMMES |
| sizeof(unsigned char))) == NULL) |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| uprintf("+++Système : Mémoire insuffisante\n"); |
uprintf("+++Système : Mémoire insuffisante\n"); |
|
Line 316 rplinit(int argc, char *argv[], char *en
|
Line 416 rplinit(int argc, char *argv[], char *en
|
| |
|
| strcpy((*s_etat_processus).localisation, d_locale); |
strcpy((*s_etat_processus).localisation, d_locale); |
| } |
} |
| # endif |
|
| |
|
| (*s_etat_processus).erreur_systeme = d_es; |
(*s_etat_processus).erreur_systeme = d_es; |
| |
|
|
Line 325 rplinit(int argc, char *argv[], char *en
|
Line 424 rplinit(int argc, char *argv[], char *en
|
| if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * |
if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| uprintf("+++Système : Mémoire insuffisante\n"); |
uprintf("+++Système : Mémoire insuffisante\n"); |
|
Line 340 rplinit(int argc, char *argv[], char *en
|
Line 451 rplinit(int argc, char *argv[], char *en
|
| strcpy((*s_etat_processus).localisation, d_locale); |
strcpy((*s_etat_processus).localisation, d_locale); |
| } |
} |
| |
|
| printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl, |
if (resultats == NULL) // Appel direct |
| ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl); |
|
| |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
{ |
| printf("+++Copyright (C) 1989 à 2011, 2012 BERTRAND Joël\n"); |
printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl, |
| } |
((*s_etat_processus).langue == 'F') |
| else |
? d_date_rpl : d_date_en_rpl); |
| { |
|
| printf("+++Copyright (C) 1989 to 2011, 2012 BERTRAND Joel\n"); |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Copyright (C) 1989 à 2022, 2023 BERTRAND Joël\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Copyright (C) 1989 to 2022, 2023 BERTRAND Joel\n"); |
| |
} |
| } |
} |
| |
|
| if (getenv("HOME") != NULL) |
if (getenv("HOME") != NULL) |
|
Line 378 rplinit(int argc, char *argv[], char *en
|
Line 493 rplinit(int argc, char *argv[], char *en
|
| if (stackoverflow_install_handler(interruption_depassement_pile, |
if (stackoverflow_install_handler(interruption_depassement_pile, |
| pile_signaux, sizeof(pile_signaux)) != 0) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 411 rplinit(int argc, char *argv[], char *en
|
Line 538 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGINT, &action, NULL) != 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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 427 rplinit(int argc, char *argv[], char *en
|
Line 570 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGINT); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 448 rplinit(int argc, char *argv[], char *en
|
Line 615 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGTERM, &action, NULL) != 0) |
if (sigaction(SIGTERM, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| erreur = d_es_signal; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 464 rplinit(int argc, char *argv[], char *en
|
Line 647 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGTERM); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 483 rplinit(int argc, char *argv[], char *en
|
Line 690 rplinit(int argc, char *argv[], char *en
|
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
| if (sigaction(SIGALRM, &action, NULL) != 0) |
if (sigaction(SIGUSR2, &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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 501 rplinit(int argc, char *argv[], char *en
|
Line 724 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGALRM); |
raise(SIGUSR2); |
| |
|
| |
attente.tv_sec = 0; |
| |
attente.tv_nsec = 1000000; |
| |
|
| |
for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) |
| |
{ |
| |
nanosleep(&attente, NULL); |
| |
} |
| |
|
| if (signal_test != SIGALRM) |
if (signal_test != SIGUSR2) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| erreur = d_es_signal; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 525 rplinit(int argc, char *argv[], char *en
|
Line 772 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGTSTP, &action, NULL) != 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Initialisation des signaux POSIX " |
printf("+++Système : Initialisation des signaux POSIX " |
|
Line 539 rplinit(int argc, char *argv[], char *en
|
Line 802 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGTSTP); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 561 rplinit(int argc, char *argv[], char *en
|
Line 848 rplinit(int argc, char *argv[], char *en
|
| action.sa_handler = interruption5; |
action.sa_handler = interruption5; |
| action.sa_flags = 0; |
action.sa_flags = 0; |
| |
|
| |
#if 0 |
| if (sigaction(SIGPIPE, &action, NULL) != 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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 579 rplinit(int argc, char *argv[], char *en
|
Line 883 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGPIPE); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 597 rplinit(int argc, char *argv[], char *en
|
Line 925 rplinit(int argc, char *argv[], char *en
|
| |
|
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| |
#endif |
| |
|
| action.sa_handler = interruption1; |
action.sa_handler = interruption1; |
| action.sa_flags = 0; |
action.sa_flags = 0; |
| |
|
| if (sigaction(SIGUSR1, &action, NULL) != 0) |
if (sigaction(SIGUSR1, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| erreur = d_es_signal; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 619 rplinit(int argc, char *argv[], char *en
|
Line 964 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGUSR1); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 651 rplinit(int argc, char *argv[], char *en
|
Line 1020 rplinit(int argc, char *argv[], char *en
|
| drapeau_encart = 'Y'; |
drapeau_encart = 'Y'; |
| debug = d_faux; |
debug = d_faux; |
| arguments = NULL; |
arguments = NULL; |
| |
l_bibliotheques = NULL; |
| |
|
| (*s_etat_processus).s_fichiers = NULL; |
(*s_etat_processus).s_fichiers = NULL; |
| (*s_etat_processus).s_sockets = NULL; |
(*s_etat_processus).s_sockets = NULL; |
|
Line 707 rplinit(int argc, char *argv[], char *en
|
Line 1077 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_a == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -a présente " |
printf("+++Erreur : option -a présente " |
|
Line 729 rplinit(int argc, char *argv[], char *en
|
Line 1116 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_A == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -A présente " |
printf("+++Erreur : option -A présente " |
|
Line 753 rplinit(int argc, char *argv[], char *en
|
Line 1157 rplinit(int argc, char *argv[], char *en
|
| if ((arguments = malloc((strlen(argv[0]) + 7) * |
if ((arguments = malloc((strlen(argv[0]) + 7) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 789 rplinit(int argc, char *argv[], char *en
|
Line 1213 rplinit(int argc, char *argv[], char *en
|
| if ((arguments = malloc((strlen(argv[0]) + 7) * |
if ((arguments = malloc((strlen(argv[0]) + 7) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 820 rplinit(int argc, char *argv[], char *en
|
Line 1264 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Aucune donnée " |
printf("+++Erreur : Aucune donnée " |
|
Line 841 rplinit(int argc, char *argv[], char *en
|
Line 1302 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_c == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -c présente " |
printf("+++Erreur : option -c présente " |
|
Line 864 rplinit(int argc, char *argv[], char *en
|
Line 1342 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_d == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -d présente " |
printf("+++Erreur : option -d présente " |
|
Line 887 rplinit(int argc, char *argv[], char *en
|
Line 1382 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_D == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -D présente " |
printf("+++Erreur : option -D présente " |
|
Line 909 rplinit(int argc, char *argv[], char *en
|
Line 1421 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_h == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -h présente " |
printf("+++Erreur : option -h présente " |
|
Line 932 rplinit(int argc, char *argv[], char *en
|
Line 1461 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_i == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -i présente " |
printf("+++Erreur : option -i présente " |
|
Line 947 rplinit(int argc, char *argv[], char *en
|
Line 1493 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else if (option_S == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : options -i et -S " |
printf("+++Erreur : options -i et -S " |
|
Line 962 rplinit(int argc, char *argv[], char *en
|
Line 1525 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else if (option_p == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : options -i et -p " |
printf("+++Erreur : options -i et -p " |
|
Line 986 rplinit(int argc, char *argv[], char *en
|
Line 1566 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_l == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -l présente " |
printf("+++Erreur : option -l présente " |
|
Line 1014 rplinit(int argc, char *argv[], char *en
|
Line 1611 rplinit(int argc, char *argv[], char *en
|
| break; |
break; |
| } |
} |
| |
|
| |
case 'm' : |
| |
{ |
| |
while(*(++argv[0]) == ' '); |
| |
argv[0]--; |
| |
|
| |
if ((*(++argv[0])) != '\0') |
| |
{ |
| |
if ((l_nouvelle_bibliotheque = malloc( |
| |
sizeof(struct_liste_chainee))) == NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
(*l_nouvelle_bibliotheque).suivant = |
| |
l_bibliotheques; |
| |
|
| |
if (((*l_nouvelle_bibliotheque).donnee = |
| |
allocation(s_etat_processus, CHN)) |
| |
== NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
if (((*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet = malloc((strlen(argv[0]) + 1) * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
strcpy((*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet, argv[0]); |
| |
argv[0] += strlen((unsigned char *) |
| |
(*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet) - 1; |
| |
|
| |
l_bibliotheques = l_nouvelle_bibliotheque; |
| |
} |
| |
else if ((--argc) > 0) |
| |
{ |
| |
argv++; |
| |
|
| |
if ((l_nouvelle_bibliotheque = malloc( |
| |
sizeof(struct_liste_chainee))) == NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
(*l_nouvelle_bibliotheque).suivant = |
| |
l_bibliotheques; |
| |
|
| |
if (((*l_nouvelle_bibliotheque).donnee = |
| |
allocation(s_etat_processus, CHN)) |
| |
== NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
if (((*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet = malloc((strlen(argv[0]) + 1) * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Mémoire " |
| |
"insuffisante\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Not enough " |
| |
"memory\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
strcpy((*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet, argv[0]); |
| |
argv[0] += strlen((unsigned char *) |
| |
(*(*l_nouvelle_bibliotheque).donnee) |
| |
.objet) - 1; |
| |
|
| |
l_bibliotheques = l_nouvelle_bibliotheque; |
| |
} |
| |
else |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Erreur : Aucune bibliothèque " |
| |
"spécifiée après l'option -A\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Error : Library required after " |
| |
"-m option\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
break; |
| |
} |
| |
|
| case 'n' : |
case 'n' : |
| { |
{ |
| if (option_n == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -n présente " |
printf("+++Erreur : option -n présente " |
|
Line 1041 rplinit(int argc, char *argv[], char *en
|
Line 1950 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_p == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -p présente " |
printf("+++Erreur : option -p présente " |
|
Line 1056 rplinit(int argc, char *argv[], char *en
|
Line 1982 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else if (option_i == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : options -i et -p " |
printf("+++Erreur : options -i et -p " |
|
Line 1079 rplinit(int argc, char *argv[], char *en
|
Line 2022 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_P > 2) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -P présente " |
printf("+++Erreur : option -P présente " |
|
Line 1102 rplinit(int argc, char *argv[], char *en
|
Line 2062 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_s == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -s présente " |
printf("+++Erreur : option -s présente " |
|
Line 1125 rplinit(int argc, char *argv[], char *en
|
Line 2102 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_S == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -S présente " |
printf("+++Erreur : option -S présente " |
|
Line 1140 rplinit(int argc, char *argv[], char *en
|
Line 2134 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else if (option_i == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : options -i et -S " |
printf("+++Erreur : options -i et -S " |
|
Line 1165 rplinit(int argc, char *argv[], char *en
|
Line 2176 rplinit(int argc, char *argv[], char *en
|
| malloc((strlen(argv[0]) + 1) * |
malloc((strlen(argv[0]) + 1) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 1199 rplinit(int argc, char *argv[], char *en
|
Line 2230 rplinit(int argc, char *argv[], char *en
|
| malloc((strlen(argv[0]) + 1) * |
malloc((strlen(argv[0]) + 1) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 1227 rplinit(int argc, char *argv[], char *en
|
Line 2278 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Aucun script " |
printf("+++Erreur : Aucun script " |
|
Line 1242 rplinit(int argc, char *argv[], char *en
|
Line 2310 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| if (((*s_etat_processus).definitions_chainees = |
if (((*s_etat_processus).definitions_chainees = |
| compactage((*s_etat_processus) |
compactage(s_etat_processus, |
| .definitions_chainees)) == NULL) |
(*s_etat_processus).definitions_chainees)) |
| |
== NULL) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 1260 rplinit(int argc, char *argv[], char *en
|
Line 2346 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| (*s_etat_processus).longueur_definitions_chainees = |
(*s_etat_processus).longueur_definitions_chainees = |
| strlen((*s_etat_processus) |
(integer8) strlen((*s_etat_processus) |
| .definitions_chainees); |
.definitions_chainees); |
| |
|
| break; |
break; |
|
Line 1270 rplinit(int argc, char *argv[], char *en
|
Line 2356 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_t == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -t présente " |
printf("+++Erreur : option -t présente " |
|
Line 1295 rplinit(int argc, char *argv[], char *en
|
Line 2398 rplinit(int argc, char *argv[], char *en
|
| if ((type_debug = malloc((strlen(argv[0]) + 1) * |
if ((type_debug = malloc((strlen(argv[0]) + 1) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 1329 rplinit(int argc, char *argv[], char *en
|
Line 2452 rplinit(int argc, char *argv[], char *en
|
| malloc((strlen(argv[0]) + 1) * |
malloc((strlen(argv[0]) + 1) * |
| sizeof(unsigned char))) == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire " |
printf("+++Système : Mémoire " |
|
Line 1356 rplinit(int argc, char *argv[], char *en
|
Line 2499 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Aucun niveau " |
printf("+++Erreur : Aucun niveau " |
|
Line 1399 rplinit(int argc, char *argv[], char *en
|
Line 2559 rplinit(int argc, char *argv[], char *en
|
| |
|
| default: |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Niveau " |
printf("+++Erreur : Niveau " |
|
Line 1422 rplinit(int argc, char *argv[], char *en
|
Line 2604 rplinit(int argc, char *argv[], char *en
|
| if (sscanf(type_debug, "%llX", |
if (sscanf(type_debug, "%llX", |
| &((*s_etat_processus).type_debug)) != 1) |
&((*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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Niveau " |
printf("+++Erreur : Niveau " |
|
Line 1444 rplinit(int argc, char *argv[], char *en
|
Line 2643 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_v == d_vrai) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : option -v présente " |
printf("+++Erreur : option -v présente " |
|
Line 1548 rplinit(int argc, char *argv[], char *en
|
Line 2764 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (debug == d_faux) |
if (debug == d_faux) |
| { |
{ |
| |
|
| # ifdef HAVE_SIGSEGV_RECOVERY |
# ifdef HAVE_SIGSEGV_RECOVERY |
| if (sigsegv_install_handler(interruption_violation_access) != 0) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 1573 rplinit(int argc, char *argv[], char *en
|
Line 2805 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGSEGV, &action, NULL) != 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Initialisation des signaux POSIX " |
printf("+++Système : Initialisation des signaux POSIX " |
|
Line 1588 rplinit(int argc, char *argv[], char *en
|
Line 2837 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGSEGV); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 1609 rplinit(int argc, char *argv[], char *en
|
Line 2883 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| # endif |
# endif |
| |
|
| |
action.sa_handler = interruption3; |
| |
action.sa_flags = 0; |
| |
|
| if (sigaction(SIGBUS, &action, NULL) != 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Initialisation des signaux POSIX " |
printf("+++Système : Initialisation des signaux POSIX " |
|
Line 1626 rplinit(int argc, char *argv[], char *en
|
Line 2927 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| signal_test = SIGTEST; |
signal_test = SIGTEST; |
| kill(getpid(), SIGBUS); |
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) |
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; |
erreur = d_es_signal; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 1655 rplinit(int argc, char *argv[], char *en
|
Line 2988 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGHUP, &action, NULL) != 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Initialisation des signaux POSIX " |
printf("+++Système : Initialisation des signaux POSIX " |
|
Line 1697 rplinit(int argc, char *argv[], char *en
|
Line 3054 rplinit(int argc, char *argv[], char *en
|
| creation_nom_fichier(s_etat_processus, (*s_etat_processus) |
creation_nom_fichier(s_etat_processus, (*s_etat_processus) |
| .chemin_fichiers_temporaires)) == NULL) |
.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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Fichier indisponible\n"); |
printf("+++Système : Fichier indisponible\n"); |
|
Line 1712 rplinit(int argc, char *argv[], char *en
|
Line 3093 rplinit(int argc, char *argv[], char *en
|
| if ((f_source = fopen(nom_fichier_temporaire, "w")) |
if ((f_source = fopen(nom_fichier_temporaire, "w")) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Fichier introuvable\n"); |
printf("+++Système : Fichier introuvable\n"); |
|
Line 1726 rplinit(int argc, char *argv[], char *en
|
Line 3131 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (fprintf(f_source, "MODE_INTERACTIF\n") < 0) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Erreur d'écriture dans un fichier\n"); |
printf("+++Système : Erreur d'écriture dans un fichier\n"); |
|
Line 1741 rplinit(int argc, char *argv[], char *en
|
Line 3170 rplinit(int argc, char *argv[], char *en
|
| if (fprintf(f_source, |
if (fprintf(f_source, |
| "<< DO HALT UNTIL FALSE END >>\n") < 0) |
"<< 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Erreur d'écriture dans un fichier\n"); |
printf("+++Système : Erreur d'écriture dans un fichier\n"); |
|
Line 1755 rplinit(int argc, char *argv[], char *en
|
Line 3208 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (fclose(f_source) != 0) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Fichier indisponible\n"); |
printf("+++Système : Fichier indisponible\n"); |
|
Line 1792 rplinit(int argc, char *argv[], char *en
|
Line 3269 rplinit(int argc, char *argv[], char *en
|
| if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) && |
if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) && |
| (option_S == d_faux)) |
(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 (presence_definition == 'O') |
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 1824 rplinit(int argc, char *argv[], char *en
|
Line 3324 rplinit(int argc, char *argv[], char *en
|
| |
|
| if ((*s_etat_processus).chemin_fichiers_temporaires == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Chemin des fichiers temporaires nul\n"); |
printf("+++Système : Chemin des fichiers temporaires nul\n"); |
|
Line 1861 rplinit(int argc, char *argv[], char *en
|
Line 3384 rplinit(int argc, char *argv[], char *en
|
| gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL); |
gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL); |
| |
|
| (*s_etat_processus).liste_mutexes = 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).test_instruction = 'N'; |
| (*s_etat_processus).nombre_arguments = 0; |
(*s_etat_processus).nombre_arguments = 0; |
|
Line 1894 rplinit(int argc, char *argv[], char *en
|
Line 3419 rplinit(int argc, char *argv[], char *en
|
| |
|
| (*s_etat_processus).s_arbre_variables = NULL; |
(*s_etat_processus).s_arbre_variables = NULL; |
| (*s_etat_processus).l_liste_variables_par_niveau = NULL; |
(*s_etat_processus).l_liste_variables_par_niveau = NULL; |
| |
(*s_etat_processus).l_liste_variables_statiques = NULL; |
| (*s_etat_processus).gel_liste_variables = d_faux; |
(*s_etat_processus).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_courante = NULL; |
| (*s_etat_processus).s_liste_variables_statiques = NULL; |
(*s_etat_processus).pointeur_variable_statique_courante = NULL; |
| (*s_etat_processus).nombre_variables_statiques = 0; |
(*s_etat_processus).pointeur_variable_partagee_courante = NULL; |
| (*s_etat_processus).nombre_variables_statiques_allouees = 0; |
|
| (*s_etat_processus).niveau_courant = 0; |
(*s_etat_processus).niveau_courant = 0; |
| (*s_etat_processus).niveau_initial = 0; |
(*s_etat_processus).niveau_initial = 0; |
| (*s_etat_processus).creation_variables_statiques = d_faux; |
(*s_etat_processus).creation_variables_statiques = d_faux; |
| (*s_etat_processus).creation_variables_partagees = d_faux; |
(*s_etat_processus).creation_variables_partagees = d_faux; |
| (*s_etat_processus).position_variable_statique_courante = 0; |
|
| |
|
| (*s_etat_processus).s_bibliotheques = NULL; |
(*s_etat_processus).s_bibliotheques = NULL; |
| (*s_etat_processus).s_instructions_externes = NULL; |
(*s_etat_processus).s_instructions_externes = NULL; |
|
Line 2032 rplinit(int argc, char *argv[], char *en
|
Line 3562 rplinit(int argc, char *argv[], char *en
|
| (*s_etat_processus).arbre_instructions = NULL; |
(*s_etat_processus).arbre_instructions = NULL; |
| |
|
| (*s_etat_processus).tid_processus_pere = pthread_self(); |
(*s_etat_processus).tid_processus_pere = pthread_self(); |
| (*s_etat_processus).tid= pthread_self(); |
(*s_etat_processus).tid = pthread_self(); |
| (*s_etat_processus).pid_processus_pere = getpid(); |
(*s_etat_processus).pid_processus_pere = getpid(); |
| (*s_etat_processus).processus_detache = d_vrai; |
(*s_etat_processus).processus_detache = d_vrai; |
| (*s_etat_processus).var_volatile_processus_pere = -1; |
(*s_etat_processus).var_volatile_processus_pere = -1; |
|
Line 2056 rplinit(int argc, char *argv[], char *en
|
Line 3586 rplinit(int argc, char *argv[], char *en
|
| |
|
| if ((*s_etat_processus).erreur_systeme != d_es) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Système : Mémoire insuffisante\n"); |
printf("+++Système : Mémoire insuffisante\n"); |
|
Line 2071 rplinit(int argc, char *argv[], char *en
|
Line 3624 rplinit(int argc, char *argv[], char *en
|
| if (((*s_etat_processus).instruction_derniere_erreur = |
if (((*s_etat_processus).instruction_derniere_erreur = |
| malloc(sizeof(unsigned char))) == NULL) |
malloc(sizeof(unsigned char))) == NULL) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2100 rplinit(int argc, char *argv[], char *en
|
Line 3676 rplinit(int argc, char *argv[], char *en
|
| if (((*s_etat_processus).instruction_courante = (unsigned char *) |
if (((*s_etat_processus).instruction_courante = (unsigned char *) |
| malloc(sizeof(unsigned char))) == NULL) |
malloc(sizeof(unsigned char))) == NULL) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2129 rplinit(int argc, char *argv[], char *en
|
Line 3728 rplinit(int argc, char *argv[], char *en
|
| (*((*s_etat_processus).l_base_pile_systeme)) |
(*((*s_etat_processus).l_base_pile_systeme)) |
| .retour_definition = 'Y'; |
.retour_definition = 'Y'; |
| |
|
| (*s_etat_processus).indep = (struct_objet *) malloc( |
(*s_etat_processus).indep = allocation(s_etat_processus, NON); |
| sizeof(struct_objet)); |
(*s_etat_processus).depend = allocation(s_etat_processus, NON); |
| (*s_etat_processus).depend = (struct_objet *) malloc( |
|
| sizeof(struct_objet)); |
|
| (*s_etat_processus).parametres_courbes_de_niveau = |
(*s_etat_processus).parametres_courbes_de_niveau = |
| (struct_objet *) malloc(sizeof(struct_objet)); |
allocation(s_etat_processus, NON); |
| |
|
| if (((*s_etat_processus).indep != NULL) && |
if (((*s_etat_processus).indep != NULL) && |
| ((*s_etat_processus).depend != NULL) && |
((*s_etat_processus).depend != NULL) && |
|
Line 2164 rplinit(int argc, char *argv[], char *en
|
Line 3761 rplinit(int argc, char *argv[], char *en
|
| ((*((*s_etat_processus). |
((*((*s_etat_processus). |
| parametres_courbes_de_niveau)).objet == NULL)) |
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; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2188 rplinit(int argc, char *argv[], char *en
|
Line 3808 rplinit(int argc, char *argv[], char *en
|
| (*((*s_etat_processus).depend)).objet)).nom == |
(*((*s_etat_processus).depend)).objet)).nom == |
| NULL)) |
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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2240 rplinit(int argc, char *argv[], char *en
|
Line 3883 rplinit(int argc, char *argv[], char *en
|
| .parametres_courbes_de_niveau)).objet)).donnee |
.parametres_courbes_de_niveau)).objet)).donnee |
| == NULL)) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2268 rplinit(int argc, char *argv[], char *en
|
Line 3934 rplinit(int argc, char *argv[], char *en
|
| .objet = malloc(10 * sizeof(unsigned char))) |
.objet = malloc(10 * sizeof(unsigned char))) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2328 rplinit(int argc, char *argv[], char *en
|
Line 4017 rplinit(int argc, char *argv[], char *en
|
| (*s_etat_processus).my2_lines = d_faux; |
(*s_etat_processus).my2_lines = d_faux; |
| (*s_etat_processus).mz2_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_evaluation_expression = 'N'; |
| (*s_etat_processus).mode_execution_programme = 'Y'; |
(*s_etat_processus).mode_execution_programme = 'Y'; |
| |
|
|
Line 2350 rplinit(int argc, char *argv[], char *en
|
Line 4025 rplinit(int argc, char *argv[], char *en
|
| if ((erreur = chainage(s_etat_processus)) != |
if ((erreur = chainage(s_etat_processus)) != |
| d_absence_erreur) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Fatal :" |
printf("+++Fatal :" |
|
Line 2378 rplinit(int argc, char *argv[], char *en
|
Line 4077 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| } |
} |
| |
|
| |
/* |
| |
* Chargement des bibliothèques pour gérer des |
| |
* types externes lors des l'analyse syntaxique et |
| |
* compilation. |
| |
*/ |
| |
|
| |
l_bibliotheque_courante = l_bibliotheques; |
| |
|
| |
while(l_bibliotheque_courante != NULL) |
| |
{ |
| |
if (empilement(s_etat_processus, &((*s_etat_processus) |
| |
.l_base_pile), (*l_bibliotheque_courante) |
| |
.donnee) == d_erreur) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Fatal :" |
| |
" Chargement de la bibliothèse %s" |
| |
" impossible\n", (unsigned char *) |
| |
(*(*l_bibliotheque_courante).donnee) |
| |
.objet); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Fatal : Cannot load library %s\n", |
| |
(*(*l_bibliotheque_courante).donnee) |
| |
.objet); |
| |
} |
| |
|
| |
if (traitement_fichier_temporaire == 'Y') |
| |
{ |
| |
if (destruction_fichier( |
| |
nom_fichier_temporaire) |
| |
== d_erreur) |
| |
{ |
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
free(nom_fichier_temporaire); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
instruction_use(s_etat_processus); |
| |
|
| |
if (depilement(s_etat_processus, &((*s_etat_processus) |
| |
.l_base_pile), &((*l_bibliotheque_courante) |
| |
.donnee)) == d_erreur) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_destroy3((*s_etat_processus).semaphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Fatal :" |
| |
" Chargement de la bibliothèse %s" |
| |
" impossible\n", (unsigned char *) |
| |
(*(*l_bibliotheque_courante).donnee) |
| |
.objet); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Fatal : Cannot load library %s\n", |
| |
(*(*l_bibliotheque_courante).donnee) |
| |
.objet); |
| |
} |
| |
|
| |
if (traitement_fichier_temporaire == 'Y') |
| |
{ |
| |
if (destruction_fichier( |
| |
nom_fichier_temporaire) |
| |
== d_erreur) |
| |
{ |
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
free(nom_fichier_temporaire); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| |
l_bibliotheque_courante = |
| |
(*l_bibliotheque_courante).suivant; |
| |
} |
| |
|
| if ((erreur = compilation(s_etat_processus)) != |
if ((erreur = compilation(s_etat_processus)) != |
| d_absence_erreur) |
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 (traitement_fichier_temporaire == 'Y') |
| { |
{ |
| if (destruction_fichier(nom_fichier_temporaire) |
if (destruction_fichier(nom_fichier_temporaire) |
|
Line 2440 rplinit(int argc, char *argv[], char *en
|
Line 4294 rplinit(int argc, char *argv[], char *en
|
| |
|
| if ((*s_etat_processus).s_arbre_variables == NULL) |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Fatal : Aucun point d'entrée\n"); |
printf("+++Fatal : Aucun point d'entrée\n"); |
|
Line 2460 rplinit(int argc, char *argv[], char *en
|
Line 4337 rplinit(int argc, char *argv[], char *en
|
| if (recherche_instruction_suivante(s_etat_processus) |
if (recherche_instruction_suivante(s_etat_processus) |
| == d_erreur) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Fatal : Aucun point d'entrée\n"); |
printf("+++Fatal : Aucun point d'entrée\n"); |
|
Line 2481 rplinit(int argc, char *argv[], char *en
|
Line 4381 rplinit(int argc, char *argv[], char *en
|
| (*s_etat_processus) |
(*s_etat_processus) |
| .instruction_courante) == d_faux) |
.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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Fatal : Aucun point d'entrée\n"); |
printf("+++Fatal : Aucun point d'entrée\n"); |
|
Line 2501 rplinit(int argc, char *argv[], char *en
|
Line 4424 rplinit(int argc, char *argv[], char *en
|
| if ((*(*s_etat_processus).pointeur_variable_courante) |
if ((*(*s_etat_processus).pointeur_variable_courante) |
| .niveau != 0) |
.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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Fatal : Aucun point d'entrée\n"); |
printf("+++Fatal : Aucun point d'entrée\n"); |
|
Line 2526 rplinit(int argc, char *argv[], char *en
|
Line 4472 rplinit(int argc, char *argv[], char *en
|
| strlen(ds_fichier_historique) + 2) * |
strlen(ds_fichier_historique) + 2) * |
| sizeof(unsigned char))) == NULL) |
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; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2544 rplinit(int argc, char *argv[], char *en
|
Line 4513 rplinit(int argc, char *argv[], char *en
|
| home, ds_fichier_historique); |
home, ds_fichier_historique); |
| |
|
| using_history(); |
using_history(); |
| |
|
| |
// Pour pouvoir utiliser le keymap avant le premier |
| |
// appel à readline(). |
| |
rl_initialize(); |
| |
|
| erreur_historique = read_history( |
erreur_historique = read_history( |
| (*s_etat_processus).nom_fichier_historique); |
(*s_etat_processus).nom_fichier_historique); |
| |
|
|
Line 2553 rplinit(int argc, char *argv[], char *en
|
Line 4527 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es; |
(*s_etat_processus).erreur_systeme = d_es; |
| encart(s_etat_processus, |
encart(s_etat_processus, |
| (unsigned long) (5 * 1000000)); |
(integer8) (5 * 1000000)); |
| |
|
| if ((*s_etat_processus).erreur_systeme != d_es) |
if ((*s_etat_processus).erreur_systeme != d_es) |
| { |
{ |
| if ((message = messages(s_etat_processus)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2596 rplinit(int argc, char *argv[], char *en
|
Line 4597 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if ((*s_etat_processus).erreur_systeme != d_es) |
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; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2613 rplinit(int argc, char *argv[], char *en
|
Line 4641 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
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') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| printf("+++Erreur : Erreur de " |
printf("+++Erreur : Erreur de " |
|
Line 2632 rplinit(int argc, char *argv[], char *en
|
Line 4687 rplinit(int argc, char *argv[], char *en
|
| (*s_etat_processus).definitions_chainees = tampon; |
(*s_etat_processus).definitions_chainees = tampon; |
| (*s_etat_processus).position_courante = 0; |
(*s_etat_processus).position_courante = 0; |
| |
|
| |
(*s_etat_processus).type_en_cours = NON; |
| recherche_type(s_etat_processus); |
recherche_type(s_etat_processus); |
| |
|
| if ((*s_etat_processus).erreur_systeme != d_es) |
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)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== NULL) |
| { |
{ |
|
Line 2666 rplinit(int argc, char *argv[], char *en
|
Line 4746 rplinit(int argc, char *argv[], char *en
|
| if ((message = messages(s_etat_processus)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2685 rplinit(int argc, char *argv[], char *en
|
Line 4792 rplinit(int argc, char *argv[], char *en
|
| printf("%s [%d]\n", message, (int) getpid()); |
printf("%s [%d]\n", message, (int) getpid()); |
| free(message); |
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); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
|
Line 2695 rplinit(int argc, char *argv[], char *en
|
Line 4826 rplinit(int argc, char *argv[], char *en
|
| if ((message = messages(s_etat_processus)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== 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; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2714 rplinit(int argc, char *argv[], char *en
|
Line 4873 rplinit(int argc, char *argv[], char *en
|
| printf("%s [%d]\n", message, (int) getpid()); |
printf("%s [%d]\n", message, (int) getpid()); |
| free(message); |
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); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
| |
empilement_pile_systeme(s_etat_processus); |
| |
|
| if (evaluation(s_etat_processus, s_objet, 'E') |
if (evaluation(s_etat_processus, s_objet, 'E') |
| == d_erreur) |
== d_erreur) |
| { |
{ |
|
Line 2725 rplinit(int argc, char *argv[], char *en
|
Line 4910 rplinit(int argc, char *argv[], char *en
|
| if ((message = messages(s_etat_processus)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2745 rplinit(int argc, char *argv[], char *en
|
Line 4957 rplinit(int argc, char *argv[], char *en
|
| (int) getpid()); |
(int) getpid()); |
| free(message); |
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); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
|
Line 2754 rplinit(int argc, char *argv[], char *en
|
Line 4994 rplinit(int argc, char *argv[], char *en
|
| if ((message = messages(s_etat_processus)) |
if ((message = messages(s_etat_processus)) |
| == NULL) |
== 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') |
if ((*s_etat_processus).langue == 'F') |
|
Line 2774 rplinit(int argc, char *argv[], char *en
|
Line 5041 rplinit(int argc, char *argv[], char *en
|
| (int) getpid()); |
(int) getpid()); |
| free(message); |
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); |
return(EXIT_FAILURE); |
| } |
} |
| } |
} |
|
Line 2804 rplinit(int argc, char *argv[], char *en
|
Line 5098 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (erreur == d_absence_erreur) |
if (erreur == d_absence_erreur) |
| { |
{ |
| if (((*s_etat_processus).var_volatile_alarme |
if (((*s_etat_processus) |
| == 0) && ((*s_etat_processus) |
|
| .arret_depuis_abort == 0) && |
.arret_depuis_abort == 0) && |
| ((*s_etat_processus).at_exit |
((*s_etat_processus).at_exit |
| != NULL)) |
!= 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, |
erreur = evaluation(s_etat_processus, |
| (*s_etat_processus).at_exit, |
(*s_etat_processus).at_exit, |
| 'E'); |
'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); |
| |
} |
| |
} |
| } |
} |
| } |
} |
| } |
} |
|
Line 2821 rplinit(int argc, char *argv[], char *en
|
Line 5195 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (setjmp(contexte_initial) == 0) |
if (setjmp(contexte_initial) == 0) |
| { |
{ |
| erreur = sequenceur_optimise(s_etat_processus); |
erreur = sequenceur_optimise(s_etat_processus, |
| |
l_bibliotheques); |
| |
|
| if (erreur == d_absence_erreur) |
if (erreur == d_absence_erreur) |
| { |
{ |
| if (((*s_etat_processus).var_volatile_alarme |
if (((*s_etat_processus) |
| == 0) && ((*s_etat_processus) |
|
| .arret_depuis_abort == 0) && |
.arret_depuis_abort == 0) && |
| ((*s_etat_processus).at_exit |
((*s_etat_processus).at_exit |
| != NULL)) |
!= 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, |
erreur = evaluation(s_etat_processus, |
| (*s_etat_processus).at_exit, |
(*s_etat_processus).at_exit, |
| 'E'); |
'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_exit); |
| liberation(s_etat_processus, (*s_etat_processus).at_poke); |
liberation(s_etat_processus, (*s_etat_processus).at_poke); |
| |
|
|
Line 2869 rplinit(int argc, char *argv[], char *en
|
Line 5329 rplinit(int argc, char *argv[], char *en
|
| pthread_cancel((*s_etat_processus).thread_fusible); |
pthread_cancel((*s_etat_processus).thread_fusible); |
| } |
} |
| |
|
| pthread_mutex_lock(&((*s_etat_processus).mutex)); |
pthread_mutex_lock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| |
|
| l_element_courant = (void *) (*s_etat_processus) |
l_element_courant = (void *) (*s_etat_processus) |
| .l_base_pile_processus; |
.l_base_pile_processus; |
|
Line 2946 rplinit(int argc, char *argv[], char *en
|
Line 5407 rplinit(int argc, char *argv[], char *en
|
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
| .thread).pid, rpl_sigurg); |
.thread).pid, rpl_sigurg, d_faux); |
| } |
} |
| else |
else |
| { |
{ |
|
Line 2957 rplinit(int argc, char *argv[], char *en
|
Line 5418 rplinit(int argc, char *argv[], char *en
|
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
| .thread).pid, rpl_sigabort); |
.thread).pid, rpl_sigabort, d_faux); |
| } |
} |
| else |
else |
| { |
{ |
|
Line 2965 rplinit(int argc, char *argv[], char *en
|
Line 5426 rplinit(int argc, char *argv[], char *en
|
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
| .thread).pid, rpl_sigstop); |
.thread).pid, rpl_sigstop, d_faux); |
| } |
} |
| } |
} |
| } |
} |
|
Line 2984 rplinit(int argc, char *argv[], char *en
|
Line 5445 rplinit(int argc, char *argv[], char *en
|
| if ((*s_etat_processus).var_volatile_alarme |
if ((*s_etat_processus).var_volatile_alarme |
| != 0) |
!= 0) |
| { |
{ |
| envoi_signal_thread( |
envoi_signal_thread(s_etat_processus, |
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
|
Line 2995 rplinit(int argc, char *argv[], char *en
|
Line 5456 rplinit(int argc, char *argv[], char *en
|
| if ((*s_etat_processus).arret_depuis_abort |
if ((*s_etat_processus).arret_depuis_abort |
| == -1) |
== -1) |
| { |
{ |
| envoi_signal_thread( |
envoi_signal_thread(s_etat_processus, |
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee) |
l_element_courant)).donnee) |
|
Line 3004 rplinit(int argc, char *argv[], char *en
|
Line 5465 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
else |
| { |
{ |
| envoi_signal_thread( |
envoi_signal_thread(s_etat_processus, |
| (*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee) |
l_element_courant)).donnee) |
|
Line 3041 rplinit(int argc, char *argv[], char *en
|
Line 5502 rplinit(int argc, char *argv[], char *en
|
| l_element_courant = (void *) |
l_element_courant = (void *) |
| (*s_etat_processus).l_base_pile_processus; |
(*s_etat_processus).l_base_pile_processus; |
| |
|
| for(i = 0; i < (unsigned long) |
for(i = 0; i < (*(*((struct_processus_fils *) |
| (*(*((struct_processus_fils *) |
|
| (*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
| l_element_courant)).donnee).objet)).thread) |
l_element_courant)).donnee).objet)).thread) |
| .nombre_objets_dans_pipe; i++) |
.nombre_objets_dans_pipe; i++) |
|
Line 3067 rplinit(int argc, char *argv[], char *en
|
Line 5527 rplinit(int argc, char *argv[], char *en
|
| if (sigaction(SIGPIPE, &action, ®istre) |
if (sigaction(SIGPIPE, &action, ®istre) |
| != 0) |
!= 0) |
| { |
{ |
| pthread_mutex_unlock( |
# ifndef SEMAPHORES_NOMMES |
| &((*s_etat_processus).mutex)); |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| |
pthread_mutex_unlock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| |
|
|
Line 3091 rplinit(int argc, char *argv[], char *en
|
Line 5578 rplinit(int argc, char *argv[], char *en
|
| if (sigaction(SIGPIPE, ®istre, NULL) |
if (sigaction(SIGPIPE, ®istre, NULL) |
| != 0) |
!= 0) |
| { |
{ |
| pthread_mutex_unlock( |
# ifndef SEMAPHORES_NOMMES |
| &((*s_etat_processus).mutex)); |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semaphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
destruction_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| |
pthread_mutex_unlock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
| } |
} |
| } |
} |
| } |
} |
| |
|
| pthread_mutex_unlock(&((*s_etat_processus).mutex)); |
pthread_mutex_lock(&((*s_etat_processus) |
| |
.mutex_interruptions)); |
| |
|
| if ((*s_etat_processus) |
if ((*s_etat_processus) |
| .nombre_interruptions_non_affectees != 0) |
.nombre_interruptions_non_affectees != 0) |
|
Line 3107 rplinit(int argc, char *argv[], char *en
|
Line 5622 rplinit(int argc, char *argv[], char *en
|
| s_etat_processus); |
s_etat_processus); |
| } |
} |
| |
|
| |
pthread_mutex_unlock(&((*s_etat_processus) |
| |
.mutex_interruptions)); |
| |
pthread_mutex_unlock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| scrutation_interruptions(s_etat_processus); |
scrutation_interruptions(s_etat_processus); |
| pthread_mutex_lock(&((*s_etat_processus).mutex)); |
pthread_mutex_lock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| } |
} |
| |
|
| pthread_mutex_unlock(&((*s_etat_processus).mutex)); |
pthread_mutex_unlock(&((*s_etat_processus) |
| |
.mutex_pile_processus)); |
| |
|
| erreur_historique = write_history( |
erreur_historique = write_history( |
| (*s_etat_processus).nom_fichier_historique); |
(*s_etat_processus).nom_fichier_historique); |
|
Line 3262 rplinit(int argc, char *argv[], char *en
|
Line 5783 rplinit(int argc, char *argv[], char *en
|
| * le libérer... |
* le libérer... |
| */ |
*/ |
| |
|
| |
liberation_arbre_variables_partagees(s_etat_processus, |
| |
(*(*s_etat_processus).s_arbre_variables_partagees)); |
| liberation_arbre_variables(s_etat_processus, |
liberation_arbre_variables(s_etat_processus, |
| (*s_etat_processus).s_arbre_variables, d_vrai); |
(*s_etat_processus).s_arbre_variables, d_vrai); |
| free((*s_etat_processus).pointeurs_caracteres_variables); |
free((*s_etat_processus).pointeurs_caracteres_variables); |
| |
|
| for(i = 0; i < (*s_etat_processus) |
l_element_statique_courant = (*s_etat_processus) |
| .nombre_variables_statiques; i++) |
.l_liste_variables_statiques; |
| |
|
| |
while(l_element_statique_courant != NULL) |
| { |
{ |
| liberation(s_etat_processus, (*s_etat_processus) |
l_element_statique_suivant = |
| .s_liste_variables_statiques[i].objet); |
(*l_element_statique_courant).suivant; |
| free((*s_etat_processus) |
free(l_element_statique_courant); |
| .s_liste_variables_statiques[i].nom); |
l_element_statique_courant = l_element_statique_suivant; |
| } |
} |
| |
|
| free((*s_etat_processus).s_liste_variables_statiques); |
l_element_partage_courant = (*(*s_etat_processus) |
| |
.l_liste_variables_partagees); |
| |
|
| for(i = 0; i < (*((*s_etat_processus) |
while(l_element_partage_courant != NULL) |
| .s_liste_variables_partagees)).nombre_variables; |
|
| i++) |
|
| { |
{ |
| liberation(s_etat_processus, (*((*s_etat_processus) |
l_element_partage_suivant = |
| .s_liste_variables_partagees)).table[i].objet); |
(*l_element_partage_courant).suivant; |
| free((*((*s_etat_processus) |
free(l_element_partage_courant); |
| .s_liste_variables_partagees)).table[i].nom); |
l_element_partage_courant = l_element_partage_suivant; |
| } |
} |
| |
|
| free((struct_variable_partagee *) |
|
| (*((*s_etat_processus).s_liste_variables_partagees)) |
|
| .table); |
|
| |
|
| /* |
/* |
| * Si resultats est non nul, rplinit a été appelé |
* Si resultats est non nul, rplinit a été appelé |
| * depuis rpl() [librpl] et non main(). |
* depuis rpl() [librpl] et non main(). |
|
Line 3303 rplinit(int argc, char *argv[], char *en
|
Line 5823 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if ((*resultats) != NULL) |
if ((*resultats) != NULL) |
| { |
{ |
| free((*resultats)); |
sys_free((*resultats)); |
| |
|
| if (((*resultats) = malloc(((*s_etat_processus) |
if (((*resultats) = sys_malloc(((size_t) |
| .hauteur_pile_operationnelle + 1) |
((*s_etat_processus) |
| |
.hauteur_pile_operationnelle + 1)) |
| * sizeof(unsigned char **))) != NULL) |
* sizeof(unsigned char **))) != NULL) |
| { |
{ |
| (*resultats)[(*s_etat_processus) |
(*resultats)[(*s_etat_processus) |
|
Line 3391 rplinit(int argc, char *argv[], char *en
|
Line 5912 rplinit(int argc, char *argv[], char *en
|
| l_element_courant = l_element_suivant; |
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_element_courant = (void *) (*s_etat_processus) |
| .l_base_pile_last; |
.l_base_pile_last; |
| while(l_element_courant != NULL) |
while(l_element_courant != NULL) |
|
Line 3441 rplinit(int argc, char *argv[], char *en
|
Line 5927 rplinit(int argc, char *argv[], char *en
|
| l_element_courant = l_element_suivant; |
l_element_courant = l_element_suivant; |
| } |
} |
| |
|
| |
while((*s_etat_processus).s_bibliotheques != NULL) |
| |
{ |
| |
retrait_bibliotheque(s_etat_processus, |
| |
(struct_bibliotheque *) |
| |
(*((struct_liste_chainee *) |
| |
(*s_etat_processus).s_bibliotheques)).donnee); |
| |
} |
| |
|
| l_element_courant = (void *) (*s_etat_processus) |
l_element_courant = (void *) (*s_etat_processus) |
| .l_base_pile_systeme; |
.l_base_pile_systeme; |
| while(l_element_courant != NULL) |
while(l_element_courant != NULL) |
|
Line 3608 rplinit(int argc, char *argv[], char *en
|
Line 6102 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (traitement_fichier_temporaire == 'Y') |
if (traitement_fichier_temporaire == 'Y') |
| { |
{ |
| if (destruction_fichier(nom_fichier_temporaire) == d_erreur) |
destruction_fichier(nom_fichier_temporaire); |
| { |
|
| return(EXIT_FAILURE); |
|
| } |
|
| |
|
| free(nom_fichier_temporaire); |
free(nom_fichier_temporaire); |
| } |
} |
| |
|
|
Line 3626 rplinit(int argc, char *argv[], char *en
|
Line 6116 rplinit(int argc, char *argv[], char *en
|
| closelog(); |
closelog(); |
| |
|
| pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes)); |
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); |
retrait_thread(s_etat_processus); |
| |
|
| pthread_mutex_destroy(&((*s_etat_processus).mutex)); |
attente.tv_sec = 0; |
| |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| |
pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)); |
| |
|
| |
while(nombre_threads_surveillance_processus != 0) |
| |
{ |
| |
pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); |
| |
nanosleep(&attente, NULL); |
| |
INCR_GRANULARITE(attente.tv_nsec); |
| |
pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)); |
| |
} |
| |
|
| |
pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); |
| |
|
| |
attente.tv_sec = 0; |
| |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| |
while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus)) |
| |
== EBUSY) |
| |
{ |
| |
nanosleep(&attente, NULL); |
| |
INCR_GRANULARITE(attente.tv_nsec); |
| |
} |
| |
|
| |
pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_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_allocation)); |
| |
pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions)); |
| |
pthread_mutex_destroy(&mutex_sections_critiques); |
| |
pthread_mutex_destroy(&mutex_liste_variables_partagees); |
| |
|
| |
free((*s_etat_processus).localisation); |
| |
|
| |
destruction_queue_signaux(s_etat_processus); |
| |
pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux)); |
| |
liberation_contexte_cas(s_etat_processus); |
| |
|
| # ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
| sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
|
Line 3643 rplinit(int argc, char *argv[], char *en
|
Line 6166 rplinit(int argc, char *argv[], char *en
|
| SEM_FORK); |
SEM_FORK); |
| # endif |
# endif |
| |
|
| free((*s_etat_processus).localisation); |
|
| |
|
| pthread_mutex_destroy(&mutex_liste_threads); |
|
| pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique); |
|
| |
|
| # ifndef SEMAPHORES_NOMMES |
|
| sem_post(&semaphore_gestionnaires_signaux); |
|
| sem_destroy(&semaphore_gestionnaires_signaux); |
|
| # else |
|
| sem_post(semaphore_gestionnaires_signaux); |
|
| sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
|
| # endif |
|
| |
|
| destruction_queue_signaux(s_etat_processus); |
|
| liberation_contexte_cas(s_etat_processus); |
|
| |
|
| free((*s_etat_processus).chemin_fichiers_temporaires); |
free((*s_etat_processus).chemin_fichiers_temporaires); |
| |
|
| if ((*s_etat_processus).requete_redemarrage == d_vrai) |
if ((*s_etat_processus).requete_redemarrage == d_vrai) |
| { |
{ |
| chdir(repertoire_initial); |
if (chdir(repertoire_initial) == 0) |
| execvp(arg_exec[0], &(arg_exec[0])); |
{ |
| |
execvp(arg_exec[0], &(arg_exec[0])); |
| |
} |
| |
|
| erreur = d_erreur; |
erreur = d_erreur; |
| } |
} |
| |
|
| free(arg_exec); |
liberation_etat_processus_readline(); |
| free(s_etat_processus); |
|
| |
liberation_allocateur_buffer(s_etat_processus); |
| |
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer)); |
| |
pthread_mutex_destroy(&mutex_liste_threads); |
| |
pthread_mutex_destroy(&mutex_liste_threads_surveillance); |
| |
pthread_mutex_destroy(&mutex_sigaction); |
| |
|
| |
sys_free(s_etat_processus); |
| |
sys_free(arg_exec); |
| |
|
| # ifdef DEBUG_MEMOIRE |
# ifdef DEBUG_MEMOIRE |
| debug_memoire_verification(); |
debug_memoire_verification(); |
|
Line 3708 informations(struct_processus *s_etat_pr
|
Line 6226 informations(struct_processus *s_etat_pr
|
| printf(" -i : fonctionnement interactif\n"); |
printf(" -i : fonctionnement interactif\n"); |
| printf(" -l : licence d'utilisation\n"); |
printf(" -l : licence d'utilisation\n"); |
| printf(" -n : ignorance du signal HUP\n"); |
printf(" -n : ignorance du signal HUP\n"); |
| |
printf(" -m : chargement d'un module RPL/SO avant la " |
| |
"compilation\n"); |
| printf(" -p : précompilation du script avant exécution\n"); |
printf(" -p : précompilation du script avant exécution\n"); |
| printf(" -P : profilage\n"); |
printf(" -P : profilage (-P ou -PP)\n"); |
| printf(" -s : empêchement de l'ouverture de l'écran initial\n"); |
printf(" -s : empêchement de l'ouverture de l'écran initial\n"); |
| printf(" -S : exécution du script passé en ligne de commande\n"); |
printf(" -S : exécution du script passé en ligne de commande\n"); |
| printf(" -t : trace\n"); |
printf(" -t : trace\n"); |
|
Line 3729 informations(struct_processus *s_etat_pr
|
Line 6249 informations(struct_processus *s_etat_pr
|
| printf(" -i : runs the RPL/2 sequencer in interactive mode\n"); |
printf(" -i : runs the RPL/2 sequencer in interactive mode\n"); |
| printf(" -l : prints the user licence of the software\n"); |
printf(" -l : prints the user licence of the software\n"); |
| printf(" -n : ignores HUP signal\n"); |
printf(" -n : ignores HUP signal\n"); |
| |
printf(" -m : loads RPL/SO object before compilation\n"); |
| printf(" -p : precompiles script\n"); |
printf(" -p : precompiles script\n"); |
| printf(" -P : computes profile data\n"); |
printf(" -P : computes profile data (-P or -PP)\n"); |
| printf(" -s : disables splash screen\n"); |
printf(" -s : disables splash screen\n"); |
| printf(" -S : executes script written in command line\n"); |
printf(" -S : executes script written in command line\n"); |
| printf(" -t : enables tracing mode\n"); |
printf(" -t : enables tracing mode\n"); |
|
Line 3795 controle_integrite(struct_processus *s_e
|
Line 6316 controle_integrite(struct_processus *s_e
|
| |
|
| |
|
| unsigned char * |
unsigned char * |
| date_compilation() |
date_compilation(struct_processus *s_etat_processus) |
| { |
{ |
| unsigned char *date; |
unsigned char *date; |
| |
|
|
Line 3810 date_compilation()
|
Line 6331 date_compilation()
|
| return(date); |
return(date); |
| } |
} |
| |
|
| |
#pragma GCC diagnostic pop |
| |
|
| // vim: ts=4 |
// vim: ts=4 |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rpl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src