|
version 1.119, 2012/10/04 15:21:26
|
version 1.124, 2012/10/19 19:05:52
|
|
Line 80 rplinit(int argc, char *argv[], char *en
|
Line 80 rplinit(int argc, char *argv[], char *en
|
| |
|
| struct_processus *s_etat_processus; |
struct_processus *s_etat_processus; |
| |
|
| |
struct_liste_variables_statiques *l_element_statique_courant; |
| |
struct_liste_variables_statiques *l_element_statique_suivant; |
| |
|
| struct_table_variables_partagees s_variables_partagees; |
struct_table_variables_partagees s_variables_partagees; |
| |
|
| struct sigaction action; |
struct sigaction action; |
|
Line 151 rplinit(int argc, char *argv[], char *en
|
Line 154 rplinit(int argc, char *argv[], char *en
|
| |
|
| if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) |
if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
# else |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
| |
# endif |
| |
|
| erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
| |
|
| if ((langue = getenv("LANG")) != NULL) |
if ((langue = getenv("LANG")) != NULL) |
|
Line 184 rplinit(int argc, char *argv[], char *en
|
Line 195 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) |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
# else |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| 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 205 rplinit(int argc, char *argv[], char *en
|
Line 217 rplinit(int argc, char *argv[], char *en
|
| |
|
| if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL) |
if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL) |
| { |
{ |
| if ((langue = getenv("LANG")) != NULL) |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
# else |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
| |
# endif |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| 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 262 rplinit(int argc, char *argv[], char *en
|
Line 275 rplinit(int argc, char *argv[], char *en
|
| 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) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
# else |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
# endif |
| |
|
| |
liberation(contexte_cas(s_etat_processus); |
| |
|
| 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 299 rplinit(int argc, char *argv[], char *en
|
Line 323 rplinit(int argc, char *argv[], char *en
|
| 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
|
| |
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 |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
if (((*s_etat_processus).localisation = malloc((strlen(d_locale) |
| |
+ 1) * sizeof(unsigned char))) == NULL) |
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
|
Line 321 rplinit(int argc, char *argv[], char *en
|
Line 393 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 330 rplinit(int argc, char *argv[], char *en
|
Line 401 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| uprintf("+++Système : Mémoire insuffisante\n"); |
uprintf("+++Système : Mémoire insuffisante\n"); |
|
Line 383 rplinit(int argc, char *argv[], char *en
|
Line 471 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| 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 516 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| # endif |
# endif |
| |
|
| |
if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur) |
| |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
erreur = d_es_signal; |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Système : Initialisation des signaux POSIX " |
| |
"impossible\n"); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++System : Initialization of POSIX signals failed\n"); |
| |
} |
| |
|
| |
return(EXIT_FAILURE); |
| |
} |
| |
|
| action.sa_handler = interruption1; |
action.sa_handler = interruption1; |
| action.sa_flags = 0; |
action.sa_flags = 0; |
| |
|
| if (sigaction(SIGINT, &action, NULL) != 0) |
if (sigaction(SIGINT, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 444 rplinit(int argc, char *argv[], char *en
|
Line 608 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGINT) |
if (signal_test != SIGINT) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 461 rplinit(int argc, char *argv[], char *en
|
Line 646 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 489 rplinit(int argc, char *argv[], char *en
|
Line 695 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGTERM) |
if (signal_test != SIGTERM) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 506 rplinit(int argc, char *argv[], char *en
|
Line 733 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGALRM, &action, NULL) != 0) |
if (sigaction(SIGALRM, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 534 rplinit(int argc, char *argv[], char *en
|
Line 782 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGALRM) |
if (signal_test != SIGALRM) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 554 rplinit(int argc, char *argv[], char *en
|
Line 823 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 580 rplinit(int argc, char *argv[], char *en
|
Line 870 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGTSTP) |
if (signal_test != SIGTSTP) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 600 rplinit(int argc, char *argv[], char *en
|
Line 911 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGPIPE, &action, NULL) != 0) |
if (sigaction(SIGPIPE, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 628 rplinit(int argc, char *argv[], char *en
|
Line 960 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGPIPE) |
if (signal_test != SIGPIPE) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 648 rplinit(int argc, char *argv[], char *en
|
Line 1001 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGUSR1, &action, NULL) != 0) |
if (sigaction(SIGUSR1, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 676 rplinit(int argc, char *argv[], char *en
|
Line 1050 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGUSR1) |
if (signal_test != SIGUSR1) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
| |
SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 760 rplinit(int argc, char *argv[], char *en
|
Line 1155 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 782 rplinit(int argc, char *argv[], char *en
|
Line 1199 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 806 rplinit(int argc, char *argv[], char *en
|
Line 1245 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 842 rplinit(int argc, char *argv[], char *en
|
Line 1308 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 873 rplinit(int argc, char *argv[], char *en
|
Line 1366 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
else |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 894 rplinit(int argc, char *argv[], char *en
|
Line 1409 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 917 rplinit(int argc, char *argv[], char *en
|
Line 1454 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 940 rplinit(int argc, char *argv[], char *en
|
Line 1499 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 962 rplinit(int argc, char *argv[], char *en
|
Line 1543 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 985 rplinit(int argc, char *argv[], char *en
|
Line 1588 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1000 rplinit(int argc, char *argv[], char *en
|
Line 1625 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1015 rplinit(int argc, char *argv[], char *en
|
Line 1662 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1039 rplinit(int argc, char *argv[], char *en
|
Line 1708 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1071 rplinit(int argc, char *argv[], char *en
|
Line 1762 rplinit(int argc, char *argv[], char *en
|
| { |
{ |
| if (option_n == d_vrai) |
if (option_n == d_vrai) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1094 rplinit(int argc, char *argv[], char *en
|
Line 1807 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1109 rplinit(int argc, char *argv[], char *en
|
Line 1844 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1132 rplinit(int argc, char *argv[], char *en
|
Line 1889 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1155 rplinit(int argc, char *argv[], char *en
|
Line 1934 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1178 rplinit(int argc, char *argv[], char *en
|
Line 1979 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1193 rplinit(int argc, char *argv[], char *en
|
Line 2016 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1218 rplinit(int argc, char *argv[], char *en
|
Line 2063 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1252 rplinit(int argc, char *argv[], char *en
|
Line 2124 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1280 rplinit(int argc, char *argv[], char *en
|
Line 2179 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
else |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1298 rplinit(int argc, char *argv[], char *en
|
Line 2219 rplinit(int argc, char *argv[], char *en
|
| compactage((*s_etat_processus) |
compactage((*s_etat_processus) |
| .definitions_chainees)) == NULL) |
.definitions_chainees)) == NULL) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_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 1323 rplinit(int argc, char *argv[], char *en
|
Line 2266 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1348 rplinit(int argc, char *argv[], char *en
|
Line 2313 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1382 rplinit(int argc, char *argv[], char *en
|
Line 2374 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1409 rplinit(int argc, char *argv[], char *en
|
Line 2428 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
else |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1452 rplinit(int argc, char *argv[], char *en
|
Line 2493 rplinit(int argc, char *argv[], char *en
|
| |
|
| default: |
default: |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_post( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post( |
| |
semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas( |
| |
s_etat_processus); |
| |
liberation_queue_signaux( |
| |
s_etat_processus); |
| |
|
| |
# 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 1475 rplinit(int argc, char *argv[], char *en
|
Line 2550 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1497 rplinit(int argc, char *argv[], char *en
|
Line 2594 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1601 rplinit(int argc, char *argv[], char *en
|
Line 2720 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1626 rplinit(int argc, char *argv[], char *en
|
Line 2766 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1653 rplinit(int argc, char *argv[], char *en
|
Line 2815 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGSEGV) |
if (signal_test != SIGSEGV) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1675 rplinit(int argc, char *argv[], char *en
|
Line 2859 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (sigaction(SIGBUS, &action, NULL) != 0) |
if (sigaction(SIGBUS, &action, NULL) != 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1702 rplinit(int argc, char *argv[], char *en
|
Line 2915 rplinit(int argc, char *argv[], char *en
|
| |
|
| if (signal_test != SIGBUS) |
if (signal_test != SIGBUS) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus).semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1727 rplinit(int argc, char *argv[], char *en
|
Line 2969 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1769 rplinit(int argc, char *argv[], char *en
|
Line 3040 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1784 rplinit(int argc, char *argv[], char *en
|
Line 3084 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1798 rplinit(int argc, char *argv[], char *en
|
Line 3127 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1813 rplinit(int argc, char *argv[], char *en
|
Line 3171 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1827 rplinit(int argc, char *argv[], char *en
|
Line 3214 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1864 rplinit(int argc, char *argv[], char *en
|
Line 3280 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 1896 rplinit(int argc, char *argv[], char *en
|
Line 3340 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2127 rplinit(int argc, char *argv[], char *en
|
Line 3599 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2142 rplinit(int argc, char *argv[], char *en
|
Line 3642 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2171 rplinit(int argc, char *argv[], char *en
|
Line 3699 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2233 rplinit(int argc, char *argv[], char *en
|
Line 3789 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2257 rplinit(int argc, char *argv[], char *en
|
Line 3841 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2309 rplinit(int argc, char *argv[], char *en
|
Line 3921 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2337 rplinit(int argc, char *argv[], char *en
|
Line 3977 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2397 rplinit(int argc, char *argv[], char *en
|
Line 4065 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 2419 rplinit(int argc, char *argv[], char *en
|
Line 4073 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2450 rplinit(int argc, char *argv[], char *en
|
Line 4133 rplinit(int argc, char *argv[], char *en
|
| 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2509 rplinit(int argc, char *argv[], char *en
|
Line 4220 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2529 rplinit(int argc, char *argv[], char *en
|
Line 4268 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2550 rplinit(int argc, char *argv[], char *en
|
Line 4317 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2570 rplinit(int argc, char *argv[], char *en
|
Line 4365 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2595 rplinit(int argc, char *argv[], char *en
|
Line 4418 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2634 rplinit(int argc, char *argv[], char *en
|
Line 4485 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2670 rplinit(int argc, char *argv[], char *en
|
Line 4555 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2687 rplinit(int argc, char *argv[], char *en
|
Line 4606 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| else |
else |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2710 rplinit(int argc, char *argv[], char *en
|
Line 4663 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2740 rplinit(int argc, char *argv[], char *en
|
Line 4722 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2759 rplinit(int argc, char *argv[], char *en
|
Line 4775 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2769 rplinit(int argc, char *argv[], char *en
|
Line 4814 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2788 rplinit(int argc, char *argv[], char *en
|
Line 4868 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus).semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2(semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus).semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2799 rplinit(int argc, char *argv[], char *en
|
Line 4908 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_post( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post( |
| |
semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2819 rplinit(int argc, char *argv[], char *en
|
Line 4967 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2828 rplinit(int argc, char *argv[], char *en
|
Line 5011 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_post( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post( |
| |
semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 2848 rplinit(int argc, char *argv[], char *en
|
Line 5070 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_post(&semaphore_gestionnaires_signaux); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post(semaphore_gestionnaires_signaux); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, |
| |
getpid(), pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# 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 3146 rplinit(int argc, char *argv[], char *en
|
Line 5402 rplinit(int argc, char *argv[], char *en
|
| if (sigaction(SIGPIPE, &action, ®istre) |
if (sigaction(SIGPIPE, &action, ®istre) |
| != 0) |
!= 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_post( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post( |
| |
semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| pthread_mutex_unlock( |
pthread_mutex_unlock( |
| &((*s_etat_processus).mutex)); |
&((*s_etat_processus).mutex)); |
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
|
Line 3170 rplinit(int argc, char *argv[], char *en
|
Line 5465 rplinit(int argc, char *argv[], char *en
|
| if (sigaction(SIGPIPE, ®istre, NULL) |
if (sigaction(SIGPIPE, ®istre, NULL) |
| != 0) |
!= 0) |
| { |
{ |
| |
# ifndef SEMAPHORES_NOMMES |
| |
sem_post(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
sem_post( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy( |
| |
&semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy(&((*s_etat_processus) |
| |
.semaphore_fork)); |
| |
# else |
| |
sem_post((*s_etat_processus) |
| |
.semaphore_fork); |
| |
sem_post( |
| |
semaphore_gestionnaires_signaux |
| |
); |
| |
sem_destroy2( |
| |
semaphore_gestionnaires_signaux, |
| |
getpid(), SEM_SIGNAUX); |
| |
sem_destroy3((*s_etat_processus) |
| |
.semphore_fork, getpid(), |
| |
pthread_self(), SEM_FORK); |
| |
# endif |
| |
|
| |
liberation_contexte_cas(s_etat_processus); |
| |
liberation_queue_signaux(s_etat_processus); |
| |
|
| |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
| |
stackoverflow_deinstall_handler(); |
| |
# endif |
| |
|
| |
# ifdef HAVE_SIGSEGV_RECOVERY |
| |
if (debug == d_faux) |
| |
{ |
| |
sigsegv_deinstall_handler(); |
| |
} |
| |
# endif |
| |
|
| pthread_mutex_unlock( |
pthread_mutex_unlock( |
| &((*s_etat_processus).mutex)); |
&((*s_etat_processus).mutex)); |
| return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
|
Line 3345 rplinit(int argc, char *argv[], char *en
|
Line 5679 rplinit(int argc, char *argv[], char *en
|
| (*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); |
| |
|
| #warning A FIXER |
l_element_statique_courant = (*s_etat_processus) |
| /* |
.l_liste_variables_statiques; |
| for(i = 0; i < (*s_etat_processus) |
|
| .nombre_variables_statiques; i++) |
while(l_element_statique_courant != NULL) |
| { |
{ |
| liberation(s_etat_processus, (*s_etat_processus) |
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); |
|
| */ |
|
| |
|
| for(i = 0; i < (*((*s_etat_processus) |
for(i = 0; i < (*((*s_etat_processus) |
| .s_liste_variables_partagees)).nombre_variables; |
.s_liste_variables_partagees)).nombre_variables; |
| i++) |
i++) |
|
Line 3690 rplinit(int argc, char *argv[], char *en
|
Line 6021 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 3749 rplinit(int argc, char *argv[], char *en
|
Line 6076 rplinit(int argc, char *argv[], char *en
|
| } |
} |
| |
|
| free(arg_exec); |
free(arg_exec); |
| |
arret_thread_signaux(s_etat_processus); |
| free(s_etat_processus); |
free(s_etat_processus); |
| |
|
| # ifdef DEBUG_MEMOIRE |
# ifdef DEBUG_MEMOIRE |
|
Line 3789 informations(struct_processus *s_etat_pr
|
Line 6117 informations(struct_processus *s_etat_pr
|
| 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(" -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 3810 informations(struct_processus *s_etat_pr
|
Line 6138 informations(struct_processus *s_etat_pr
|
| 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(" -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"); |
![[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