![[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|
Return to rpl.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.118 bertrand 3: RPL/2 (R) version 4.1.11
1.107 bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #define MAIN_RPL
1.35 bertrand 24: #include "rpl-conv.h"
1.1 bertrand 25:
1.37 bertrand 26:
1.1 bertrand 27: /*
28: ================================================================================
29: Programme principal
30: ================================================================================
31: */
32:
33: int
1.101 bertrand 34: rplinit(int argc, char *argv[], char *envp[],
35: unsigned char ***resultats, char *rpl_home)
1.1 bertrand 36: {
1.35 bertrand 37: # include "copyright-conv.h"
38: # include "licence-conv.h"
1.1 bertrand 39:
1.104 bertrand 40: char **arg_exec;
41:
1.97 bertrand 42: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
1.94 bertrand 43: char pile_signaux[SIGSTKSZ];
1.97 bertrand 44: # endif
1.94 bertrand 45:
1.103 bertrand 46: # define RPL_PATH_MAX 1024
47: char repertoire_initial[RPL_PATH_MAX];
48:
1.1 bertrand 49: file *f_source;
50:
51: int erreur_historique;
52: int option_P;
53:
54: logical1 core;
55: logical1 debug;
56: logical1 erreur_fichier;
57: logical1 existence;
58: logical1 mode_interactif;
59: logical1 option_a;
60: logical1 option_A;
61: logical1 option_c;
62: logical1 option_d;
63: logical1 option_D;
64: logical1 option_h;
65: logical1 option_i;
66: logical1 option_l;
67: logical1 option_n;
68: logical1 option_p;
69: logical1 option_s;
70: logical1 option_S;
71: logical1 option_t;
72: logical1 option_v;
73: logical1 ouverture;
74:
75: pthread_mutexattr_t attributs_mutex;
76:
77: ssize_t longueur_ecriture;
78:
79: struct_objet *s_objet;
80:
81: struct_processus *s_etat_processus;
82:
1.121 bertrand 83: struct_liste_variables_statiques *l_element_statique_courant;
84: struct_liste_variables_statiques *l_element_statique_suivant;
85:
1.1 bertrand 86: struct_table_variables_partagees s_variables_partagees;
87:
88: struct sigaction action;
89: struct sigaction registre;
90:
91: struct timespec attente;
92:
93: unsigned char *arguments;
94: unsigned char drapeau_encart;
95: unsigned char *type_debug;
96: unsigned char *home;
97: unsigned char *langue;
98: unsigned char *message;
99: unsigned char *nom_fichier_temporaire;
100: unsigned char option;
101: unsigned char presence_definition;
102: unsigned char *ptr;
103: unsigned char *tampon;
104:
105: unsigned long i;
106: unsigned long unite_fichier;
107:
108: void *l_element_courant;
109: void *l_element_suivant;
110:
111: volatile int erreur;
112: volatile unsigned char traitement_fichier_temporaire;
113:
1.37 bertrand 114: errno = 0;
1.85 bertrand 115: s_queue_signaux = NULL;
1.94 bertrand 116: routine_recursive = 0;
1.82 bertrand 117: pid_processus_pere = getpid();
1.37 bertrand 118:
1.27 bertrand 119: # ifdef DEBUG_MEMOIRE
120: debug_memoire_initialisation();
121: # endif
122:
1.1 bertrand 123: setvbuf(stdout, NULL, _IOLBF, 0);
124: setvbuf(stderr, NULL, _IOLBF, 0);
125:
1.17 bertrand 126: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 127: sem_init(&semaphore_gestionnaires_signaux, 0, 0);
1.17 bertrand 128: # else
1.92 bertrand 129: semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);
1.84 bertrand 130:
131: if (semaphore_gestionnaires_signaux == SEM_FAILED)
1.17 bertrand 132: {
133: erreur = d_es_allocation_memoire;
134:
135: if ((langue = getenv("LANG")) != NULL)
136: {
137: if (strncmp(langue, "fr", 2) == 0)
138: {
139: uprintf("+++Système : Mémoire insuffisante\n");
140: }
141: else
142: {
143: uprintf("+++System : Not enough memory\n");
144: }
145: }
146: else
147: {
148: uprintf("+++System : Not enough memory\n");
149: }
150:
151: return(EXIT_FAILURE);
152: }
153: # endif
1.1 bertrand 154:
155: if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
156: {
1.124 ! bertrand 157: # ifndef SEMAPHORES_NOMMES
! 158: sem_post(&semaphore_gestionnaires_signaux);
! 159: sem_destroy(&semaphore_gestionnaires_signaux);
! 160: # else
! 161: sem_post(semaphore_gestionnaires_signaux);
! 162: sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
! 163: # endif
! 164:
1.1 bertrand 165: erreur = d_es_allocation_memoire;
166:
1.17 bertrand 167: if ((langue = getenv("LANG")) != NULL)
1.1 bertrand 168: {
1.17 bertrand 169: if (strncmp(langue, "fr", 2) == 0)
170: {
171: uprintf("+++Système : Mémoire insuffisante\n");
172: }
173: else
174: {
175: uprintf("+++System : Not enough memory\n");
176: }
1.1 bertrand 177: }
178: else
179: {
1.17 bertrand 180: uprintf("+++System : Not enough memory\n");
1.1 bertrand 181: }
182:
183: return(EXIT_FAILURE);
184: }
185:
1.17 bertrand 186: if ((langue = getenv("LANG")) != NULL)
187: {
188: (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
189: ? 'F' : 'E';
190: }
191: else
192: {
193: (*s_etat_processus).langue = 'E';
194: }
195:
1.103 bertrand 196: if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
197: {
1.124 ! bertrand 198: # ifndef SEMAPHORES_NOMMES
! 199: sem_post(&semaphore_gestionnaires_signaux);
! 200: sem_destroy(&semaphore_gestionnaires_signaux);
! 201: # else
! 202: sem_post(semaphore_gestionnaires_signaux);
! 203: sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
! 204: # endif
! 205:
! 206: if ((*s_etat_processus).langue == 'F')
1.103 bertrand 207: {
1.124 ! bertrand 208: uprintf("+++Système : Mémoire insuffisante\n");
1.103 bertrand 209: }
210: else
211: {
212: uprintf("+++System : Not enough memory\n");
213: }
214:
215: return(EXIT_FAILURE);
216: }
217:
1.104 bertrand 218: if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL)
219: {
1.124 ! bertrand 220: # ifndef SEMAPHORES_NOMMES
! 221: sem_post(&semaphore_gestionnaires_signaux);
! 222: sem_destroy(&semaphore_gestionnaires_signaux);
! 223: # else
! 224: sem_post(semaphore_gestionnaires_signaux);
! 225: sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
! 226: # endif
! 227:
! 228: if ((*s_etat_processus).langue == 'F')
1.104 bertrand 229: {
1.124 ! bertrand 230: uprintf("+++Système : Mémoire insuffisante\n");
1.104 bertrand 231: }
232: else
233: {
234: uprintf("+++System : Not enough memory\n");
235: }
236:
237: return(EXIT_FAILURE);
238: }
239:
240: for(i = 0; i < (unsigned long) argc; i++)
241: {
242: arg_exec[i] = argv[i];
243: }
244:
245: argv[argc] = NULL;
246:
1.76 bertrand 247: initialisation_contexte_cas(s_etat_processus);
248:
1.1 bertrand 249: (*s_etat_processus).exception = d_ep;
250: (*s_etat_processus).erreur_systeme = d_es;
251: (*s_etat_processus).erreur_execution = d_ex;
252:
1.102 bertrand 253: (*s_etat_processus).requete_redemarrage = d_faux;
1.11 bertrand 254: (*s_etat_processus).rpl_home = rpl_home;
255:
1.1 bertrand 256: pthread_mutexattr_init(&attributs_mutex);
257: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
258: pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
259: pthread_mutexattr_destroy(&attributs_mutex);
260:
1.30 bertrand 261: pthread_mutexattr_init(&attributs_mutex);
262: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
263: pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
264: &attributs_mutex);
265: pthread_mutexattr_destroy(&attributs_mutex);
266:
1.117 bertrand 267: pthread_mutexattr_init(&attributs_mutex);
268: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
269: pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
270: pthread_mutexattr_destroy(&attributs_mutex);
271:
1.91 bertrand 272: # ifndef SEMAPHORES_NOMMES
273: sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
274: # else
275: if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
1.92 bertrand 276: pthread_self(), SEM_FORK)) == SEM_FAILED)
1.91 bertrand 277: {
1.124 ! bertrand 278: # ifndef SEMAPHORES_NOMMES
! 279: sem_post(&semaphore_gestionnaires_signaux);
! 280: sem_destroy(&semaphore_gestionnaires_signaux);
! 281: # else
! 282: sem_post(semaphore_gestionnaires_signaux);
! 283: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 284: SEM_SIGNAUX);
! 285: # endif
! 286:
! 287: liberation(contexte_cas(s_etat_processus);
! 288:
1.91 bertrand 289: if ((*s_etat_processus).langue == 'F')
290: {
291: uprintf("+++Système : Mémoire insuffisante\n");
292: }
293: else
294: {
295: uprintf("+++System : Not enough memory\n");
296: }
297:
298: return(EXIT_FAILURE);
299: }
300: # endif
1.1 bertrand 301:
302: pthread_mutexattr_init(&attributs_mutex);
303: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
304: pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
305: &attributs_mutex);
306: pthread_mutexattr_destroy(&attributs_mutex);
307:
308: (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees;
309:
310: s_variables_partagees.nombre_variables = 0;
311: s_variables_partagees.nombre_variables_allouees = 0;
312: s_variables_partagees.table = NULL;
313:
314: pthread_mutexattr_init(&attributs_mutex);
315: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
316: pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees))
317: .mutex), &attributs_mutex);
318: pthread_mutexattr_destroy(&attributs_mutex);
319:
1.40 bertrand 320: (*s_etat_processus).chemin_fichiers_temporaires =
321: recherche_chemin_fichiers_temporaires(s_etat_processus);
322:
1.43 bertrand 323: insertion_thread(s_etat_processus, d_vrai);
1.83 bertrand 324: creation_queue_signaux(s_etat_processus);
1.40 bertrand 325:
1.124 ! bertrand 326: if ((*s_etat_processus).erreur_systeme != d_es)
! 327: {
! 328: # ifndef SEMAPHORES_NOMMES
! 329: sem_post(&((*s_etat_processus).semaphore_fork));
! 330: sem_post(&semaphore_gestionnaires_signaux);
! 331: sem_destroy(&semaphore_gestionnaires_signaux);
! 332: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 333: # else
! 334: sem_post((*s_etat_processus).semaphore_fork);
! 335: sem_post(semaphore_gestionnaires_signaux);
! 336: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 337: SEM_SIGNAUX);
! 338: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 339: pthread_self(), SEM_FORK);
! 340: # endif
! 341:
! 342: liberation_contexte_cas(s_etat_processus);
! 343:
! 344: if ((*s_etat_processus).langue == 'F')
! 345: {
! 346: uprintf("+++Système : Mémoire insuffisante\n");
! 347: }
! 348: else
! 349: {
! 350: uprintf("+++System : Not enough memory\n");
! 351: }
! 352:
! 353: return(EXIT_FAILURE);
! 354: }
! 355:
1.123 bertrand 356: if (d_forced_locale == 0)
357: {
358: localisation_courante(s_etat_processus);
359: }
360: else
1.42 bertrand 361: {
1.124 ! bertrand 362: # ifndef SEMAPHORES_NOMMES
! 363: sem_post(&((*s_etat_processus).semaphore_fork));
! 364: sem_post(&semaphore_gestionnaires_signaux);
! 365: sem_destroy(&semaphore_gestionnaires_signaux);
! 366: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 367: # else
! 368: sem_post((*s_etat_processus).semaphore_fork);
! 369: sem_post(semaphore_gestionnaires_signaux);
! 370: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 371: SEM_SIGNAUX);
! 372: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 373: pthread_self(), SEM_FORK);
! 374: # endif
! 375:
! 376: liberation_contexte_cas(s_etat_processus);
! 377: liberation_queue_signaux(s_etat_processus);
! 378:
! 379: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
! 380: + 1) * sizeof(unsigned char))) == NULL)
1.42 bertrand 381: {
1.124 ! bertrand 382: if ((*s_etat_processus).langue == 'F')
! 383: {
! 384: uprintf("+++Système : Mémoire insuffisante\n");
! 385: }
! 386: else
1.42 bertrand 387: {
1.124 ! bertrand 388: uprintf("+++System : Not enough memory\n");
1.42 bertrand 389: }
390:
1.124 ! bertrand 391: return(EXIT_FAILURE);
1.42 bertrand 392: }
1.124 ! bertrand 393:
! 394: strcpy((*s_etat_processus).localisation, d_locale);
1.42 bertrand 395: }
1.40 bertrand 396:
1.17 bertrand 397: (*s_etat_processus).erreur_systeme = d_es;
1.1 bertrand 398:
1.17 bertrand 399: if ((*s_etat_processus).localisation == NULL)
1.1 bertrand 400: {
1.17 bertrand 401: if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
402: sizeof(unsigned char))) == NULL)
1.1 bertrand 403: {
1.124 ! bertrand 404: # ifndef SEMAPHORES_NOMMES
! 405: sem_post(&((*s_etat_processus).semaphore_fork));
! 406: sem_post(&semaphore_gestionnaires_signaux);
! 407: sem_destroy(&semaphore_gestionnaires_signaux);
! 408: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 409: # else
! 410: sem_post((*s_etat_processus).semaphore_fork);
! 411: sem_post(semaphore_gestionnaires_signaux);
! 412: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 413: SEM_SIGNAUX);
! 414: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 415: pthread_self(), SEM_FORK);
! 416: # endif
! 417:
! 418: liberation_contexte_cas(s_etat_processus);
! 419: liberation_queue_signaux(s_etat_processus);
! 420:
1.17 bertrand 421: if ((*s_etat_processus).langue == 'F')
422: {
423: uprintf("+++Système : Mémoire insuffisante\n");
424: }
425: else
426: {
427: uprintf("+++System : Not enough memory\n");
428: }
429:
430: return(EXIT_FAILURE);
1.1 bertrand 431: }
432:
1.17 bertrand 433: strcpy((*s_etat_processus).localisation, d_locale);
1.1 bertrand 434: }
435:
436: printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
437: ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);
438:
439: if ((*s_etat_processus).langue == 'F')
440: {
1.107 bertrand 441: printf("+++Copyright (C) 1989 à 2011, 2012 BERTRAND Joël\n");
1.1 bertrand 442: }
443: else
444: {
1.107 bertrand 445: printf("+++Copyright (C) 1989 to 2011, 2012 BERTRAND Joel\n");
1.1 bertrand 446: }
447:
448: if (getenv("HOME") != NULL)
449: {
450: home = getenv("HOME");
451: }
452: else if ((getenv("USER") != NULL) && (getpwnam(getenv("USER")) != NULL))
453: {
454: home = getpwnam(getenv("USER"))->pw_dir;
455: }
456: else if ((getenv("LOGNAME") != NULL) && (getpwnam(getenv("LOGNAME"))
457: != NULL))
458: {
459: home = getpwnam(getenv("LOGNAME"))->pw_dir;
460: }
461: else if ((getuid() != ((uid_t) -1)) && (getpwuid(getuid()) != NULL))
462: {
463: home = getpwuid(getuid())->pw_dir;
464: }
465: else
466: {
467: home = "";
468: }
469:
1.94 bertrand 470: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
471: if (stackoverflow_install_handler(interruption_depassement_pile,
472: pile_signaux, sizeof(pile_signaux)) != 0)
473: {
1.124 ! bertrand 474: # ifndef SEMAPHORES_NOMMES
! 475: sem_post(&((*s_etat_processus).semaphore_fork));
! 476: sem_post(&semaphore_gestionnaires_signaux);
! 477: sem_destroy(&semaphore_gestionnaires_signaux);
! 478: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 479: # else
! 480: sem_post((*s_etat_processus).semaphore_fork);
! 481: sem_post(semaphore_gestionnaires_signaux);
! 482: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 483: SEM_SIGNAUX);
! 484: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 485: pthread_self(), SEM_FORK);
! 486: # endif
! 487:
! 488: liberation_contexte_cas(s_etat_processus);
! 489: liberation_queue_signaux(s_etat_processus);
! 490:
1.94 bertrand 491: erreur = d_es_signal;
1.1 bertrand 492:
1.94 bertrand 493: if ((*s_etat_processus).langue == 'F')
494: {
495: printf("+++Système : Initialisation de la pile alternative "
496: "impossible\n");
497: }
498: else
499: {
500: printf("+++System : Initialization of alternate "
501: "stack failed\n");
502: }
1.1 bertrand 503:
1.94 bertrand 504: return(EXIT_FAILURE);
1.1 bertrand 505: }
1.94 bertrand 506: # else
1.1 bertrand 507: if ((*s_etat_processus).langue == 'F')
508: {
1.94 bertrand 509: printf("+++Attention : Le système ne supporte pas de pile "
510: "alternative\n");
1.1 bertrand 511: }
512: else
513: {
1.94 bertrand 514: printf("+++Warning : Operating system does not support alternate "
515: "stack\n");
1.1 bertrand 516: }
1.9 bertrand 517: # endif
1.1 bertrand 518:
1.122 bertrand 519: if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
520: {
1.124 ! bertrand 521: # ifndef SEMAPHORES_NOMMES
! 522: sem_post(&((*s_etat_processus).semaphore_fork));
! 523: sem_post(&semaphore_gestionnaires_signaux);
! 524: sem_destroy(&semaphore_gestionnaires_signaux);
! 525: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 526: # else
! 527: sem_post((*s_etat_processus).semaphore_fork);
! 528: sem_post(semaphore_gestionnaires_signaux);
! 529: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 530: SEM_SIGNAUX);
! 531: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 532: pthread_self(), SEM_FORK);
! 533: # endif
! 534:
! 535: liberation_contexte_cas(s_etat_processus);
! 536: liberation_queue_signaux(s_etat_processus);
! 537:
! 538: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 539: stackoverflow_deinstall_handler();
! 540: # endif
! 541:
1.122 bertrand 542: erreur = d_es_signal;
543:
544: if ((*s_etat_processus).langue == 'F')
545: {
546: printf("+++Système : Initialisation des signaux POSIX "
547: "impossible\n");
548: }
549: else
550: {
551: printf("+++System : Initialization of POSIX signals failed\n");
552: }
553:
554: return(EXIT_FAILURE);
555: }
556:
1.40 bertrand 557: action.sa_handler = interruption1;
1.94 bertrand 558: action.sa_flags = 0;
1.1 bertrand 559:
560: if (sigaction(SIGINT, &action, NULL) != 0)
561: {
1.124 ! bertrand 562: # ifndef SEMAPHORES_NOMMES
! 563: sem_post(&((*s_etat_processus).semaphore_fork));
! 564: sem_post(&semaphore_gestionnaires_signaux);
! 565: sem_destroy(&semaphore_gestionnaires_signaux);
! 566: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 567: # else
! 568: sem_post((*s_etat_processus).semaphore_fork);
! 569: sem_post(semaphore_gestionnaires_signaux);
! 570: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 571: SEM_SIGNAUX);
! 572: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 573: pthread_self(), SEM_FORK);
! 574: # endif
! 575:
! 576: liberation_contexte_cas(s_etat_processus);
! 577: liberation_queue_signaux(s_etat_processus);
! 578:
! 579: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 580: stackoverflow_deinstall_handler();
! 581: # endif
! 582:
1.1 bertrand 583: erreur = d_es_signal;
584:
585: if ((*s_etat_processus).langue == 'F')
586: {
587: printf("+++Système : Initialisation des signaux POSIX "
588: "impossible\n");
589: }
590: else
591: {
592: printf("+++System : Initialization of POSIX signals failed\n");
593: }
594:
595: return(EXIT_FAILURE);
596: }
597:
1.81 bertrand 598: signal_test = SIGTEST;
599: kill(getpid(), SIGINT);
600:
1.115 bertrand 601: attente.tv_sec = 0;
602: attente.tv_nsec = 1000000;
603:
604: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
605: {
606: nanosleep(&attente, NULL);
607: }
608:
1.81 bertrand 609: if (signal_test != SIGINT)
610: {
1.124 ! bertrand 611: # ifndef SEMAPHORES_NOMMES
! 612: sem_post(&((*s_etat_processus).semaphore_fork));
! 613: sem_post(&semaphore_gestionnaires_signaux);
! 614: sem_destroy(&semaphore_gestionnaires_signaux);
! 615: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 616: # else
! 617: sem_post((*s_etat_processus).semaphore_fork);
! 618: sem_post(semaphore_gestionnaires_signaux);
! 619: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 620: SEM_SIGNAUX);
! 621: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 622: pthread_self(), SEM_FORK);
! 623: # endif
! 624:
! 625: liberation_contexte_cas(s_etat_processus);
! 626: liberation_queue_signaux(s_etat_processus);
! 627:
! 628: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 629: stackoverflow_deinstall_handler();
! 630: # endif
! 631:
1.81 bertrand 632: erreur = d_es_signal;
633:
634: if ((*s_etat_processus).langue == 'F')
635: {
636: printf("+++Système : Initialisation des signaux POSIX "
637: "impossible\n");
638: }
639: else
640: {
641: printf("+++System : Initialization of POSIX signals failed\n");
642: }
643:
644: return(EXIT_FAILURE);
645: }
646:
1.54 bertrand 647: if (sigaction(SIGTERM, &action, NULL) != 0)
648: {
1.124 ! bertrand 649: # ifndef SEMAPHORES_NOMMES
! 650: sem_post(&((*s_etat_processus).semaphore_fork));
! 651: sem_post(&semaphore_gestionnaires_signaux);
! 652: sem_destroy(&semaphore_gestionnaires_signaux);
! 653: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 654: # else
! 655: sem_post((*s_etat_processus).semaphore_fork);
! 656: sem_post(semaphore_gestionnaires_signaux);
! 657: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 658: SEM_SIGNAUX);
! 659: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 660: pthread_self(), SEM_FORK);
! 661: # endif
! 662:
! 663: liberation_contexte_cas(s_etat_processus);
! 664: liberation_queue_signaux(s_etat_processus);
! 665:
! 666: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 667: stackoverflow_deinstall_handler();
! 668: # endif
! 669:
1.54 bertrand 670: erreur = d_es_signal;
671:
672: if ((*s_etat_processus).langue == 'F')
673: {
674: printf("+++Système : Initialisation des signaux POSIX "
675: "impossible\n");
676: }
677: else
678: {
679: printf("+++System : Initialization of POSIX signals failed\n");
680: }
681:
682: return(EXIT_FAILURE);
683: }
684:
1.81 bertrand 685: signal_test = SIGTEST;
686: kill(getpid(), SIGTERM);
687:
1.115 bertrand 688: attente.tv_sec = 0;
689: attente.tv_nsec = 1000000;
690:
691: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
692: {
693: nanosleep(&attente, NULL);
694: }
695:
1.81 bertrand 696: if (signal_test != SIGTERM)
697: {
1.124 ! bertrand 698: # ifndef SEMAPHORES_NOMMES
! 699: sem_post(&((*s_etat_processus).semaphore_fork));
! 700: sem_post(&semaphore_gestionnaires_signaux);
! 701: sem_destroy(&semaphore_gestionnaires_signaux);
! 702: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 703: # else
! 704: sem_post((*s_etat_processus).semaphore_fork);
! 705: sem_post(semaphore_gestionnaires_signaux);
! 706: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 707: SEM_SIGNAUX);
! 708: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 709: pthread_self(), SEM_FORK);
! 710: # endif
! 711:
! 712: liberation_contexte_cas(s_etat_processus);
! 713: liberation_queue_signaux(s_etat_processus);
! 714:
! 715: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 716: stackoverflow_deinstall_handler();
! 717: # endif
! 718:
1.81 bertrand 719: erreur = d_es_signal;
720:
721: if ((*s_etat_processus).langue == 'F')
722: {
723: printf("+++Système : Initialisation des signaux POSIX "
724: "impossible\n");
725: }
726: else
727: {
728: printf("+++System : Initialization of POSIX signals failed\n");
729: }
730:
731: return(EXIT_FAILURE);
732: }
733:
1.106 bertrand 734: if (sigaction(SIGALRM, &action, NULL) != 0)
735: {
1.124 ! bertrand 736: # ifndef SEMAPHORES_NOMMES
! 737: sem_post(&((*s_etat_processus).semaphore_fork));
! 738: sem_post(&semaphore_gestionnaires_signaux);
! 739: sem_destroy(&semaphore_gestionnaires_signaux);
! 740: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 741: # else
! 742: sem_post((*s_etat_processus).semaphore_fork);
! 743: sem_post(semaphore_gestionnaires_signaux);
! 744: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 745: SEM_SIGNAUX);
! 746: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 747: pthread_self(), SEM_FORK);
! 748: # endif
! 749:
! 750: liberation_contexte_cas(s_etat_processus);
! 751: liberation_queue_signaux(s_etat_processus);
! 752:
! 753: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 754: stackoverflow_deinstall_handler();
! 755: # endif
! 756:
1.106 bertrand 757: erreur = d_es_signal;
758:
759: if ((*s_etat_processus).langue == 'F')
760: {
761: printf("+++Système : Initialisation des signaux POSIX "
762: "impossible\n");
763: }
764: else
765: {
766: printf("+++System : Initialization of POSIX signals failed\n");
767: }
768:
769: return(EXIT_FAILURE);
770: }
771:
772: signal_test = SIGTEST;
773: kill(getpid(), SIGALRM);
774:
1.115 bertrand 775: attente.tv_sec = 0;
776: attente.tv_nsec = 1000000;
777:
778: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
779: {
780: nanosleep(&attente, NULL);
781: }
782:
1.106 bertrand 783: if (signal_test != SIGALRM)
784: {
1.124 ! bertrand 785: # ifndef SEMAPHORES_NOMMES
! 786: sem_post(&((*s_etat_processus).semaphore_fork));
! 787: sem_post(&semaphore_gestionnaires_signaux);
! 788: sem_destroy(&semaphore_gestionnaires_signaux);
! 789: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 790: # else
! 791: sem_post((*s_etat_processus).semaphore_fork);
! 792: sem_post(semaphore_gestionnaires_signaux);
! 793: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 794: SEM_SIGNAUX);
! 795: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 796: pthread_self(), SEM_FORK);
! 797: # endif
! 798:
! 799: liberation_contexte_cas(s_etat_processus);
! 800: liberation_queue_signaux(s_etat_processus);
! 801:
! 802: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 803: stackoverflow_deinstall_handler();
! 804: # endif
! 805:
1.106 bertrand 806: erreur = d_es_signal;
807:
808: if ((*s_etat_processus).langue == 'F')
809: {
810: printf("+++Système : Initialisation des signaux POSIX "
811: "impossible\n");
812: }
813: else
814: {
815: printf("+++System : Initialization of POSIX signals failed\n");
816: }
817:
818: return(EXIT_FAILURE);
819: }
820:
1.40 bertrand 821: action.sa_handler = interruption2;
1.94 bertrand 822: action.sa_flags = 0;
1.1 bertrand 823:
824: if (sigaction(SIGTSTP, &action, NULL) != 0)
825: {
1.124 ! bertrand 826: # ifndef SEMAPHORES_NOMMES
! 827: sem_post(&((*s_etat_processus).semaphore_fork));
! 828: sem_post(&semaphore_gestionnaires_signaux);
! 829: sem_destroy(&semaphore_gestionnaires_signaux);
! 830: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 831: # else
! 832: sem_post((*s_etat_processus).semaphore_fork);
! 833: sem_post(semaphore_gestionnaires_signaux);
! 834: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 835: SEM_SIGNAUX);
! 836: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 837: pthread_self(), SEM_FORK);
! 838: # endif
! 839:
! 840: liberation_contexte_cas(s_etat_processus);
! 841: liberation_queue_signaux(s_etat_processus);
! 842:
! 843: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 844: stackoverflow_deinstall_handler();
! 845: # endif
! 846:
1.1 bertrand 847: if ((*s_etat_processus).langue == 'F')
848: {
849: printf("+++Système : Initialisation des signaux POSIX "
850: "impossible\n");
851: }
852: else
853: {
854: printf("+++System : Initialization of POSIX signals failed\n");
855: }
856:
857: return(EXIT_FAILURE);
858: }
859:
1.81 bertrand 860: signal_test = SIGTEST;
861: kill(getpid(), SIGTSTP);
862:
1.115 bertrand 863: attente.tv_sec = 0;
864: attente.tv_nsec = 1000000;
865:
866: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
867: {
868: nanosleep(&attente, NULL);
869: }
870:
1.81 bertrand 871: if (signal_test != SIGTSTP)
872: {
1.124 ! bertrand 873: # ifndef SEMAPHORES_NOMMES
! 874: sem_post(&((*s_etat_processus).semaphore_fork));
! 875: sem_post(&semaphore_gestionnaires_signaux);
! 876: sem_destroy(&semaphore_gestionnaires_signaux);
! 877: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 878: # else
! 879: sem_post((*s_etat_processus).semaphore_fork);
! 880: sem_post(semaphore_gestionnaires_signaux);
! 881: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 882: SEM_SIGNAUX);
! 883: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 884: pthread_self(), SEM_FORK);
! 885: # endif
! 886:
! 887: liberation_contexte_cas(s_etat_processus);
! 888: liberation_queue_signaux(s_etat_processus);
! 889:
! 890: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 891: stackoverflow_deinstall_handler();
! 892: # endif
! 893:
1.81 bertrand 894: erreur = d_es_signal;
895:
896: if ((*s_etat_processus).langue == 'F')
897: {
898: printf("+++Système : Initialisation des signaux POSIX "
899: "impossible\n");
900: }
901: else
902: {
903: printf("+++System : Initialization of POSIX signals failed\n");
904: }
905:
906: return(EXIT_FAILURE);
907: }
908:
1.40 bertrand 909: action.sa_handler = interruption5;
1.94 bertrand 910: action.sa_flags = 0;
1.1 bertrand 911:
912: if (sigaction(SIGPIPE, &action, NULL) != 0)
913: {
1.124 ! bertrand 914: # ifndef SEMAPHORES_NOMMES
! 915: sem_post(&((*s_etat_processus).semaphore_fork));
! 916: sem_post(&semaphore_gestionnaires_signaux);
! 917: sem_destroy(&semaphore_gestionnaires_signaux);
! 918: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 919: # else
! 920: sem_post((*s_etat_processus).semaphore_fork);
! 921: sem_post(semaphore_gestionnaires_signaux);
! 922: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 923: SEM_SIGNAUX);
! 924: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 925: pthread_self(), SEM_FORK);
! 926: # endif
! 927:
! 928: liberation_contexte_cas(s_etat_processus);
! 929: liberation_queue_signaux(s_etat_processus);
! 930:
! 931: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 932: stackoverflow_deinstall_handler();
! 933: # endif
! 934:
1.1 bertrand 935: erreur = d_es_signal;
936:
937: if ((*s_etat_processus).langue == 'F')
938: {
939: printf("+++Système : Initialisation des signaux POSIX "
940: "impossible\n");
941: }
942: else
943: {
944: printf("+++System : Initialization of POSIX signals failed\n");
945: }
946:
947: return(EXIT_FAILURE);
948: }
949:
1.81 bertrand 950: signal_test = SIGTEST;
951: kill(getpid(), SIGPIPE);
952:
1.115 bertrand 953: attente.tv_sec = 0;
954: attente.tv_nsec = 1000000;
955:
956: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
957: {
958: nanosleep(&attente, NULL);
959: }
960:
1.81 bertrand 961: if (signal_test != SIGPIPE)
962: {
1.124 ! bertrand 963: # ifndef SEMAPHORES_NOMMES
! 964: sem_post(&((*s_etat_processus).semaphore_fork));
! 965: sem_post(&semaphore_gestionnaires_signaux);
! 966: sem_destroy(&semaphore_gestionnaires_signaux);
! 967: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 968: # else
! 969: sem_post((*s_etat_processus).semaphore_fork);
! 970: sem_post(semaphore_gestionnaires_signaux);
! 971: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 972: SEM_SIGNAUX);
! 973: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 974: pthread_self(), SEM_FORK);
! 975: # endif
! 976:
! 977: liberation_contexte_cas(s_etat_processus);
! 978: liberation_queue_signaux(s_etat_processus);
! 979:
! 980: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 981: stackoverflow_deinstall_handler();
! 982: # endif
! 983:
1.81 bertrand 984: erreur = d_es_signal;
985:
986: if ((*s_etat_processus).langue == 'F')
987: {
988: printf("+++Système : Initialisation des signaux POSIX "
989: "impossible\n");
990: }
991: else
992: {
993: printf("+++System : Initialization of POSIX signals failed\n");
994: }
995:
996: return(EXIT_FAILURE);
997: }
998:
1.40 bertrand 999: action.sa_handler = interruption1;
1.94 bertrand 1000: action.sa_flags = 0;
1.1 bertrand 1001:
1.94 bertrand 1002: if (sigaction(SIGUSR1, &action, NULL) != 0)
1.1 bertrand 1003: {
1.124 ! bertrand 1004: # ifndef SEMAPHORES_NOMMES
! 1005: sem_post(&((*s_etat_processus).semaphore_fork));
! 1006: sem_post(&semaphore_gestionnaires_signaux);
! 1007: sem_destroy(&semaphore_gestionnaires_signaux);
! 1008: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 1009: # else
! 1010: sem_post((*s_etat_processus).semaphore_fork);
! 1011: sem_post(semaphore_gestionnaires_signaux);
! 1012: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 1013: SEM_SIGNAUX);
! 1014: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 1015: pthread_self(), SEM_FORK);
! 1016: # endif
! 1017:
! 1018: liberation_contexte_cas(s_etat_processus);
! 1019: liberation_queue_signaux(s_etat_processus);
! 1020:
! 1021: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1022: stackoverflow_deinstall_handler();
! 1023: # endif
! 1024:
1.1 bertrand 1025: erreur = d_es_signal;
1026:
1027: if ((*s_etat_processus).langue == 'F')
1028: {
1029: printf("+++Système : Initialisation des signaux POSIX "
1030: "impossible\n");
1031: }
1032: else
1033: {
1034: printf("+++System : Initialization of POSIX signals failed\n");
1035: }
1036:
1037: return(EXIT_FAILURE);
1038: }
1039:
1.81 bertrand 1040: signal_test = SIGTEST;
1.94 bertrand 1041: kill(getpid(), SIGUSR1);
1.81 bertrand 1042:
1.115 bertrand 1043: attente.tv_sec = 0;
1044: attente.tv_nsec = 1000000;
1045:
1046: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
1047: {
1048: nanosleep(&attente, NULL);
1049: }
1050:
1.94 bertrand 1051: if (signal_test != SIGUSR1)
1.81 bertrand 1052: {
1.124 ! bertrand 1053: # ifndef SEMAPHORES_NOMMES
! 1054: sem_post(&((*s_etat_processus).semaphore_fork));
! 1055: sem_post(&semaphore_gestionnaires_signaux);
! 1056: sem_destroy(&semaphore_gestionnaires_signaux);
! 1057: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 1058: # else
! 1059: sem_post((*s_etat_processus).semaphore_fork);
! 1060: sem_post(semaphore_gestionnaires_signaux);
! 1061: sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
! 1062: SEM_SIGNAUX);
! 1063: sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
! 1064: pthread_self(), SEM_FORK);
! 1065: # endif
! 1066:
! 1067: liberation_contexte_cas(s_etat_processus);
! 1068: liberation_queue_signaux(s_etat_processus);
! 1069:
! 1070: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1071: stackoverflow_deinstall_handler();
! 1072: # endif
! 1073:
1.81 bertrand 1074: erreur = d_es_signal;
1075:
1076: if ((*s_etat_processus).langue == 'F')
1077: {
1078: printf("+++Système : Initialisation des signaux POSIX "
1079: "impossible\n");
1080: }
1081: else
1082: {
1083: printf("+++System : Initialization of POSIX signals failed\n");
1084: }
1085:
1086: return(EXIT_FAILURE);
1087: }
1088:
1.82 bertrand 1089: signal_test = SIGTEST + 1;
1.1 bertrand 1090:
1.13 bertrand 1091: erreur = d_absence_erreur;
1.1 bertrand 1092: core = d_faux;
1093: mode_interactif = d_faux;
1094: (*s_etat_processus).nom_fichier_source = NULL;
1095: (*s_etat_processus).definitions_chainees = NULL;
1096: (*s_etat_processus).type_debug = 0;
1097: traitement_fichier_temporaire = 'N';
1098: option = ' ';
1099: drapeau_encart = 'Y';
1100: debug = d_faux;
1101: arguments = NULL;
1102:
1103: (*s_etat_processus).s_fichiers = NULL;
1104: (*s_etat_processus).s_sockets = NULL;
1105: (*s_etat_processus).s_connecteurs_sql = NULL;
1106:
1107: setlogmask(LOG_MASK(LOG_NOTICE));
1108: openlog(argv[0], LOG_ODELAY | LOG_PID, LOG_USER);
1109:
1110: if (argc == 1)
1111: {
1.13 bertrand 1112: erreur = d_erreur;
1.1 bertrand 1113: informations(s_etat_processus);
1114: }
1115: else
1116: {
1117: presence_definition = 'N';
1118: (*s_etat_processus).debug = d_faux;
1119: (*s_etat_processus).lancement_interactif = d_faux;
1120:
1121: option_a = d_faux;
1122: option_A = d_faux;
1123: option_c = d_faux;
1124: option_d = d_faux;
1125: option_D = d_faux;
1126: option_h = d_faux;
1127: option_i = d_faux;
1128: option_l = d_faux;
1129: option_n = d_faux;
1130: option_p = d_faux;
1131: option_P = 0;
1132: option_s = d_faux;
1133: option_S = d_faux;
1134: option_t = d_faux;
1135: option_v = d_faux;
1136:
1.86 bertrand 1137: // Lorsque le programme est appelé depuis un shebang, argv[0] contient
1138: // le chemin du programme et argv[1] tous les arguments.
1139: // argv[2] contient quant à lui le nom du script RPL/2.
1140: //
1141: // Exemple :
1142: // argv[0] : /usr/local/bin/rpl
1143: // argv[1] : -csdp -t 800
1144: // argv[2] : ./on_exit.rpl
1145:
1.1 bertrand 1146: while((--argc) > 0)
1147: {
1148: if ((*(++argv))[0] == '-')
1149: {
1150: while((option = *(++argv[0])) != '\0')
1151: {
1152: switch(option)
1153: {
1154: case 'a' :
1155: {
1156: if (option_a == d_vrai)
1157: {
1.124 ! bertrand 1158: # ifndef SEMAPHORES_NOMMES
! 1159: sem_post(&((*s_etat_processus).semaphore_fork));
! 1160: sem_post(&semaphore_gestionnaires_signaux);
! 1161: sem_destroy(&semaphore_gestionnaires_signaux);
! 1162: sem_destroy(&((*s_etat_processus)
! 1163: .semaphore_fork));
! 1164: # else
! 1165: sem_post((*s_etat_processus).semaphore_fork);
! 1166: sem_post(semaphore_gestionnaires_signaux);
! 1167: sem_destroy2(semaphore_gestionnaires_signaux,
! 1168: getpid(), SEM_SIGNAUX);
! 1169: sem_destroy3((*s_etat_processus).semphore_fork,
! 1170: getpid(), pthread_self(), SEM_FORK);
! 1171: # endif
! 1172:
! 1173: liberation_contexte_cas(s_etat_processus);
! 1174: liberation_queue_signaux(s_etat_processus);
! 1175:
! 1176: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1177: stackoverflow_deinstall_handler();
! 1178: # endif
! 1179:
1.1 bertrand 1180: if ((*s_etat_processus).langue == 'F')
1181: {
1182: printf("+++Erreur : option -a présente "
1183: "plus d'une fois\n");
1184: }
1185: else
1186: {
1187: printf("+++Error : more than one -a "
1188: "on command line");
1189: }
1190:
1191: return(EXIT_FAILURE);
1192: }
1193:
1194: option_a = d_vrai;
1195: break;
1196: }
1197:
1198: case 'A' :
1199: {
1200: if (option_A == d_vrai)
1201: {
1.124 ! bertrand 1202: # ifndef SEMAPHORES_NOMMES
! 1203: sem_post(&((*s_etat_processus).semaphore_fork));
! 1204: sem_post(&semaphore_gestionnaires_signaux);
! 1205: sem_destroy(&semaphore_gestionnaires_signaux);
! 1206: sem_destroy(&((*s_etat_processus)
! 1207: .semaphore_fork));
! 1208: # else
! 1209: sem_post((*s_etat_processus).semaphore_fork);
! 1210: sem_post(semaphore_gestionnaires_signaux);
! 1211: sem_destroy2(semaphore_gestionnaires_signaux,
! 1212: getpid(), SEM_SIGNAUX);
! 1213: sem_destroy3((*s_etat_processus).semphore_fork,
! 1214: getpid(), pthread_self(), SEM_FORK);
! 1215: # endif
! 1216:
! 1217: liberation_contexte_cas(s_etat_processus);
! 1218: liberation_queue_signaux(s_etat_processus);
! 1219:
! 1220: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1221: stackoverflow_deinstall_handler();
! 1222: # endif
! 1223:
1.1 bertrand 1224: if ((*s_etat_processus).langue == 'F')
1225: {
1226: printf("+++Erreur : option -A présente "
1227: "plus d'une fois\n");
1228: }
1229: else
1230: {
1231: printf("+++Error : more than one -A "
1232: "on command line");
1233: }
1234:
1235: return(EXIT_FAILURE);
1236: }
1237:
1238: option_A = d_vrai;
1239:
1240: while(*(++argv[0]) == ' ');
1241: argv[0]--;
1242:
1243: if ((*(++argv[0])) != '\0')
1244: {
1245: if ((arguments = malloc((strlen(argv[0]) + 7) *
1246: sizeof(unsigned char))) == NULL)
1247: {
1.124 ! bertrand 1248: # ifndef SEMAPHORES_NOMMES
! 1249: sem_post(&((*s_etat_processus)
! 1250: .semaphore_fork));
! 1251: sem_post(&semaphore_gestionnaires_signaux);
! 1252: sem_destroy(
! 1253: &semaphore_gestionnaires_signaux);
! 1254: sem_destroy(&((*s_etat_processus)
! 1255: .semaphore_fork));
! 1256: # else
! 1257: sem_post((*s_etat_processus)
! 1258: .semaphore_fork);
! 1259: sem_post(semaphore_gestionnaires_signaux);
! 1260: sem_destroy2(
! 1261: semaphore_gestionnaires_signaux,
! 1262: getpid(), SEM_SIGNAUX);
! 1263: sem_destroy3((*s_etat_processus)
! 1264: .semphore_fork, getpid(),
! 1265: pthread_self(), SEM_FORK);
! 1266: # endif
! 1267:
! 1268: liberation_contexte_cas(s_etat_processus);
! 1269: liberation_queue_signaux(s_etat_processus);
! 1270:
! 1271: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1272: stackoverflow_deinstall_handler();
! 1273: # endif
! 1274:
1.1 bertrand 1275: if ((*s_etat_processus).langue == 'F')
1276: {
1277: printf("+++Système : Mémoire "
1278: "insuffisante\n");
1279: }
1280: else
1281: {
1282: printf("+++System : Not enough "
1283: "memory\n");
1284: }
1285:
1286: return(EXIT_FAILURE);
1287: }
1288:
1289: ptr = arguments;
1290: (*ptr) = d_code_fin_chaine;
1291: strcat(ptr, "<< ");
1292: ptr += 3;
1293:
1294: while(*(argv[0]) != '\0')
1295: {
1296: *(ptr++) = *(argv[0]++);
1297: }
1298:
1299: (*ptr) = '\0';
1300:
1301: strcat(arguments, " >>");
1302: argv[0]--;
1303: }
1304: else if ((--argc) > 0)
1305: {
1306: argv++;
1307:
1308: if ((arguments = malloc((strlen(argv[0]) + 7) *
1309: sizeof(unsigned char))) == NULL)
1310: {
1.124 ! bertrand 1311: # ifndef SEMAPHORES_NOMMES
! 1312: sem_post(&((*s_etat_processus)
! 1313: .semaphore_fork));
! 1314: sem_post(&semaphore_gestionnaires_signaux);
! 1315: sem_destroy(
! 1316: &semaphore_gestionnaires_signaux);
! 1317: sem_destroy(&((*s_etat_processus)
! 1318: .semaphore_fork));
! 1319: # else
! 1320: sem_post((*s_etat_processus)
! 1321: .semaphore_fork);
! 1322: sem_post(semaphore_gestionnaires_signaux);
! 1323: sem_destroy2(
! 1324: semaphore_gestionnaires_signaux,
! 1325: getpid(), SEM_SIGNAUX);
! 1326: sem_destroy3((*s_etat_processus)
! 1327: .semphore_fork, getpid(),
! 1328: pthread_self(), SEM_FORK);
! 1329: # endif
! 1330:
! 1331: liberation_contexte_cas(s_etat_processus);
! 1332: liberation_queue_signaux(s_etat_processus);
! 1333:
! 1334: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1335: stackoverflow_deinstall_handler();
! 1336: # endif
! 1337:
1.1 bertrand 1338: if ((*s_etat_processus).langue == 'F')
1339: {
1340: printf("+++Système : Mémoire "
1341: "insuffisante\n");
1342: }
1343: else
1344: {
1345: printf("+++System : Not enough "
1346: "memory\n");
1347: }
1348:
1349: return(EXIT_FAILURE);
1350: }
1351:
1352: ptr = arguments;
1353: (*ptr) = d_code_fin_chaine;
1354: strcat(ptr, "<< ");
1355: ptr += 3;
1356:
1357: while(*(argv[0]) != '\0')
1358: {
1359: *(ptr++) = *(argv[0]++);
1360: }
1361:
1362: (*ptr) = '\0';
1363:
1364: strcat(arguments, " >>");
1365: argv[0]--;
1366: }
1367: else
1368: {
1.124 ! bertrand 1369: # ifndef SEMAPHORES_NOMMES
! 1370: sem_post(&((*s_etat_processus).semaphore_fork));
! 1371: sem_post(&semaphore_gestionnaires_signaux);
! 1372: sem_destroy(&semaphore_gestionnaires_signaux);
! 1373: sem_destroy(&((*s_etat_processus)
! 1374: .semaphore_fork));
! 1375: # else
! 1376: sem_post((*s_etat_processus).semaphore_fork);
! 1377: sem_post(semaphore_gestionnaires_signaux);
! 1378: sem_destroy2(semaphore_gestionnaires_signaux,
! 1379: getpid(), SEM_SIGNAUX);
! 1380: sem_destroy3((*s_etat_processus).semphore_fork,
! 1381: getpid(), pthread_self(), SEM_FORK);
! 1382: # endif
! 1383:
! 1384: liberation_contexte_cas(s_etat_processus);
! 1385: liberation_queue_signaux(s_etat_processus);
! 1386:
! 1387: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1388: stackoverflow_deinstall_handler();
! 1389: # endif
! 1390:
1.1 bertrand 1391: if ((*s_etat_processus).langue == 'F')
1392: {
1393: printf("+++Erreur : Aucune donnée "
1394: "spécifié après l'option -A\n");
1395: }
1396: else
1397: {
1398: printf("+++Error : Data required after "
1399: "-A option\n");
1400: }
1401:
1402: return(EXIT_FAILURE);
1403: }
1404:
1405: break;
1406: }
1407:
1408: case 'c' :
1409: {
1410: if (option_c == d_vrai)
1411: {
1.124 ! bertrand 1412: # ifndef SEMAPHORES_NOMMES
! 1413: sem_post(&((*s_etat_processus).semaphore_fork));
! 1414: sem_post(&semaphore_gestionnaires_signaux);
! 1415: sem_destroy(&semaphore_gestionnaires_signaux);
! 1416: sem_destroy(&((*s_etat_processus)
! 1417: .semaphore_fork));
! 1418: # else
! 1419: sem_post((*s_etat_processus).semaphore_fork);
! 1420: sem_post(semaphore_gestionnaires_signaux);
! 1421: sem_destroy2(semaphore_gestionnaires_signaux,
! 1422: getpid(), SEM_SIGNAUX);
! 1423: sem_destroy3((*s_etat_processus).semphore_fork,
! 1424: getpid(), pthread_self(), SEM_FORK);
! 1425: # endif
! 1426:
! 1427: liberation_contexte_cas(s_etat_processus);
! 1428: liberation_queue_signaux(s_etat_processus);
! 1429:
! 1430: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1431: stackoverflow_deinstall_handler();
! 1432: # endif
! 1433:
1.1 bertrand 1434: if ((*s_etat_processus).langue == 'F')
1435: {
1436: printf("+++Erreur : option -c présente "
1437: "plus d'une fois\n");
1438: }
1439: else
1440: {
1441: printf("+++Error : more than one -c "
1442: "on command line");
1443: }
1444:
1445: return(EXIT_FAILURE);
1446: }
1447:
1448: option_c = d_vrai;
1449: core = d_vrai;
1450: break;
1451: }
1452:
1453: case 'd' :
1454: {
1455: if (option_d == d_vrai)
1456: {
1.124 ! bertrand 1457: # ifndef SEMAPHORES_NOMMES
! 1458: sem_post(&((*s_etat_processus).semaphore_fork));
! 1459: sem_post(&semaphore_gestionnaires_signaux);
! 1460: sem_destroy(&semaphore_gestionnaires_signaux);
! 1461: sem_destroy(&((*s_etat_processus)
! 1462: .semaphore_fork));
! 1463: # else
! 1464: sem_post((*s_etat_processus).semaphore_fork);
! 1465: sem_post(semaphore_gestionnaires_signaux);
! 1466: sem_destroy2(semaphore_gestionnaires_signaux,
! 1467: getpid(), SEM_SIGNAUX);
! 1468: sem_destroy3((*s_etat_processus).semphore_fork,
! 1469: getpid(), pthread_self(), SEM_FORK);
! 1470: # endif
! 1471:
! 1472: liberation_contexte_cas(s_etat_processus);
! 1473: liberation_queue_signaux(s_etat_processus);
! 1474:
! 1475: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1476: stackoverflow_deinstall_handler();
! 1477: # endif
! 1478:
1.1 bertrand 1479: if ((*s_etat_processus).langue == 'F')
1480: {
1481: printf("+++Erreur : option -d présente "
1482: "plus d'une fois\n");
1483: }
1484: else
1485: {
1486: printf("+++Error : more than one -d "
1487: "on command line");
1488: }
1489:
1490: return(EXIT_FAILURE);
1491: }
1492:
1493: option_d = d_vrai;
1494: debug = d_vrai;
1495: break;
1496: }
1497:
1498: case 'D' :
1499: {
1500: if (option_D == d_vrai)
1501: {
1.124 ! bertrand 1502: # ifndef SEMAPHORES_NOMMES
! 1503: sem_post(&((*s_etat_processus).semaphore_fork));
! 1504: sem_post(&semaphore_gestionnaires_signaux);
! 1505: sem_destroy(&semaphore_gestionnaires_signaux);
! 1506: sem_destroy(&((*s_etat_processus)
! 1507: .semaphore_fork));
! 1508: # else
! 1509: sem_post((*s_etat_processus).semaphore_fork);
! 1510: sem_post(semaphore_gestionnaires_signaux);
! 1511: sem_destroy2(semaphore_gestionnaires_signaux,
! 1512: getpid(), SEM_SIGNAUX);
! 1513: sem_destroy3((*s_etat_processus).semphore_fork,
! 1514: getpid(), pthread_self(), SEM_FORK);
! 1515: # endif
! 1516:
! 1517: liberation_contexte_cas(s_etat_processus);
! 1518: liberation_queue_signaux(s_etat_processus);
! 1519:
! 1520: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1521: stackoverflow_deinstall_handler();
! 1522: # endif
! 1523:
1.1 bertrand 1524: if ((*s_etat_processus).langue == 'F')
1525: {
1526: printf("+++Erreur : option -D présente "
1527: "plus d'une fois\n");
1528: }
1529: else
1530: {
1531: printf("+++Error : more than one -D "
1532: "on command line");
1533: }
1534:
1535: return(EXIT_FAILURE);
1536: }
1537:
1538: option_D = d_vrai;
1539: break;
1540: }
1541:
1542: case 'h' :
1543: {
1544: if (option_h == d_vrai)
1545: {
1.124 ! bertrand 1546: # ifndef SEMAPHORES_NOMMES
! 1547: sem_post(&((*s_etat_processus).semaphore_fork));
! 1548: sem_post(&semaphore_gestionnaires_signaux);
! 1549: sem_destroy(&semaphore_gestionnaires_signaux);
! 1550: sem_destroy(&((*s_etat_processus)
! 1551: .semaphore_fork));
! 1552: # else
! 1553: sem_post((*s_etat_processus).semaphore_fork);
! 1554: sem_post(semaphore_gestionnaires_signaux);
! 1555: sem_destroy2(semaphore_gestionnaires_signaux,
! 1556: getpid(), SEM_SIGNAUX);
! 1557: sem_destroy3((*s_etat_processus).semphore_fork,
! 1558: getpid(), pthread_self(), SEM_FORK);
! 1559: # endif
! 1560:
! 1561: liberation_contexte_cas(s_etat_processus);
! 1562: liberation_queue_signaux(s_etat_processus);
! 1563:
! 1564: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1565: stackoverflow_deinstall_handler();
! 1566: # endif
! 1567:
1.1 bertrand 1568: if ((*s_etat_processus).langue == 'F')
1569: {
1570: printf("+++Erreur : option -h présente "
1571: "plus d'une fois\n");
1572: }
1573: else
1574: {
1575: printf("+++Error : more than one -h "
1576: "on command line");
1577: }
1578:
1579: return(EXIT_FAILURE);
1580: }
1581:
1582: option_h = d_vrai;
1583: informations(s_etat_processus);
1584: break;
1585: }
1586:
1587: case 'i' :
1588: {
1589: if (option_i == d_vrai)
1590: {
1.124 ! bertrand 1591: # ifndef SEMAPHORES_NOMMES
! 1592: sem_post(&((*s_etat_processus).semaphore_fork));
! 1593: sem_post(&semaphore_gestionnaires_signaux);
! 1594: sem_destroy(&semaphore_gestionnaires_signaux);
! 1595: sem_destroy(&((*s_etat_processus)
! 1596: .semaphore_fork));
! 1597: # else
! 1598: sem_post((*s_etat_processus).semaphore_fork);
! 1599: sem_post(semaphore_gestionnaires_signaux);
! 1600: sem_destroy2(semaphore_gestionnaires_signaux,
! 1601: getpid(), SEM_SIGNAUX);
! 1602: sem_destroy3((*s_etat_processus).semphore_fork,
! 1603: getpid(), pthread_self(), SEM_FORK);
! 1604: # endif
! 1605:
! 1606: liberation_contexte_cas(s_etat_processus);
! 1607: liberation_queue_signaux(s_etat_processus);
! 1608:
! 1609: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1610: stackoverflow_deinstall_handler();
! 1611: # endif
! 1612:
1.1 bertrand 1613: if ((*s_etat_processus).langue == 'F')
1614: {
1615: printf("+++Erreur : option -i présente "
1616: "plus d'une fois\n");
1617: }
1618: else
1619: {
1620: printf("+++Error : more than one -i "
1621: "on command line");
1622: }
1623:
1624: return(EXIT_FAILURE);
1625: }
1626: else if (option_S == d_vrai)
1627: {
1.124 ! bertrand 1628: # ifndef SEMAPHORES_NOMMES
! 1629: sem_post(&((*s_etat_processus).semaphore_fork));
! 1630: sem_post(&semaphore_gestionnaires_signaux);
! 1631: sem_destroy(&semaphore_gestionnaires_signaux);
! 1632: sem_destroy(&((*s_etat_processus)
! 1633: .semaphore_fork));
! 1634: # else
! 1635: sem_post((*s_etat_processus).semaphore_fork);
! 1636: sem_post(semaphore_gestionnaires_signaux);
! 1637: sem_destroy2(semaphore_gestionnaires_signaux,
! 1638: getpid(), SEM_SIGNAUX);
! 1639: sem_destroy3((*s_etat_processus).semphore_fork,
! 1640: getpid(), pthread_self(), SEM_FORK);
! 1641: # endif
! 1642:
! 1643: liberation_contexte_cas(s_etat_processus);
! 1644: liberation_queue_signaux(s_etat_processus);
! 1645:
! 1646: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1647: stackoverflow_deinstall_handler();
! 1648: # endif
! 1649:
1.1 bertrand 1650: if ((*s_etat_processus).langue == 'F')
1651: {
1652: printf("+++Erreur : options -i et -S "
1653: "incompatibles\n");
1654: }
1655: else
1656: {
1657: printf("+++Error : incompatible options -i "
1658: "and -S\n");
1659: }
1660:
1661: return(EXIT_FAILURE);
1662: }
1663: else if (option_p == d_vrai)
1664: {
1.124 ! bertrand 1665: # ifndef SEMAPHORES_NOMMES
! 1666: sem_post(&((*s_etat_processus).semaphore_fork));
! 1667: sem_post(&semaphore_gestionnaires_signaux);
! 1668: sem_destroy(&semaphore_gestionnaires_signaux);
! 1669: sem_destroy(&((*s_etat_processus)
! 1670: .semaphore_fork));
! 1671: # else
! 1672: sem_post((*s_etat_processus).semaphore_fork);
! 1673: sem_post(semaphore_gestionnaires_signaux);
! 1674: sem_destroy2(semaphore_gestionnaires_signaux,
! 1675: getpid(), SEM_SIGNAUX);
! 1676: sem_destroy3((*s_etat_processus).semphore_fork,
! 1677: getpid(), pthread_self(), SEM_FORK);
! 1678: # endif
! 1679:
! 1680: liberation_contexte_cas(s_etat_processus);
! 1681: liberation_queue_signaux(s_etat_processus);
! 1682:
! 1683: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1684: stackoverflow_deinstall_handler();
! 1685: # endif
! 1686:
1.1 bertrand 1687: if ((*s_etat_processus).langue == 'F')
1688: {
1689: printf("+++Erreur : options -i et -p "
1690: "incompatibles\n");
1691: }
1692: else
1693: {
1694: printf("+++Error : incompatible options -i "
1695: "and -p\n");
1696: }
1697:
1698: return(EXIT_FAILURE);
1699: }
1700:
1701: option_i = d_vrai;
1702: mode_interactif = d_vrai;
1703: presence_definition = 'O';
1704: break;
1705: }
1706:
1707: case 'l' :
1708: {
1709: if (option_l == d_vrai)
1710: {
1.124 ! bertrand 1711: # ifndef SEMAPHORES_NOMMES
! 1712: sem_post(&((*s_etat_processus).semaphore_fork));
! 1713: sem_post(&semaphore_gestionnaires_signaux);
! 1714: sem_destroy(&semaphore_gestionnaires_signaux);
! 1715: sem_destroy(&((*s_etat_processus)
! 1716: .semaphore_fork));
! 1717: # else
! 1718: sem_post((*s_etat_processus).semaphore_fork);
! 1719: sem_post(semaphore_gestionnaires_signaux);
! 1720: sem_destroy2(semaphore_gestionnaires_signaux,
! 1721: getpid(), SEM_SIGNAUX);
! 1722: sem_destroy3((*s_etat_processus).semphore_fork,
! 1723: getpid(), pthread_self(), SEM_FORK);
! 1724: # endif
! 1725:
! 1726: liberation_contexte_cas(s_etat_processus);
! 1727: liberation_queue_signaux(s_etat_processus);
! 1728:
! 1729: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1730: stackoverflow_deinstall_handler();
! 1731: # endif
! 1732:
1.1 bertrand 1733: if ((*s_etat_processus).langue == 'F')
1734: {
1735: printf("+++Erreur : option -l présente "
1736: "plus d'une fois\n");
1737: }
1738: else
1739: {
1740: printf("+++Error : more than one -l "
1741: "on command line");
1742: }
1743:
1744: return(EXIT_FAILURE);
1745: }
1746:
1747: option_l = d_vrai;
1748:
1749: if ((*s_etat_processus).langue == 'F')
1750: {
1751: printf("%s\n\n", CeCILL_fr);
1752: }
1753: else
1754: {
1755: printf("%s\n\n", CeCILL_en);
1756: }
1757:
1758: break;
1759: }
1760:
1761: case 'n' :
1762: {
1763: if (option_n == d_vrai)
1764: {
1.124 ! bertrand 1765: # ifndef SEMAPHORES_NOMMES
! 1766: sem_post(&((*s_etat_processus).semaphore_fork));
! 1767: sem_post(&semaphore_gestionnaires_signaux);
! 1768: sem_destroy(&semaphore_gestionnaires_signaux);
! 1769: sem_destroy(&((*s_etat_processus)
! 1770: .semaphore_fork));
! 1771: # else
! 1772: sem_post((*s_etat_processus).semaphore_fork);
! 1773: sem_post(semaphore_gestionnaires_signaux);
! 1774: sem_destroy2(semaphore_gestionnaires_signaux,
! 1775: getpid(), SEM_SIGNAUX);
! 1776: sem_destroy3((*s_etat_processus).semphore_fork,
! 1777: getpid(), pthread_self(), SEM_FORK);
! 1778: # endif
! 1779:
! 1780: liberation_contexte_cas(s_etat_processus);
! 1781: liberation_queue_signaux(s_etat_processus);
! 1782:
! 1783: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1784: stackoverflow_deinstall_handler();
! 1785: # endif
! 1786:
1.1 bertrand 1787: if ((*s_etat_processus).langue == 'F')
1788: {
1789: printf("+++Erreur : option -n présente "
1790: "plus d'une fois\n");
1791: }
1792: else
1793: {
1794: printf("+++Error : more than one -n "
1795: "on command line");
1796: }
1797:
1798: return(EXIT_FAILURE);
1799: }
1800:
1801: option_n = d_vrai;
1802:
1803: break;
1804: }
1805:
1806: case 'p' :
1807: {
1808: if (option_p == d_vrai)
1809: {
1.124 ! bertrand 1810: # ifndef SEMAPHORES_NOMMES
! 1811: sem_post(&((*s_etat_processus).semaphore_fork));
! 1812: sem_post(&semaphore_gestionnaires_signaux);
! 1813: sem_destroy(&semaphore_gestionnaires_signaux);
! 1814: sem_destroy(&((*s_etat_processus)
! 1815: .semaphore_fork));
! 1816: # else
! 1817: sem_post((*s_etat_processus).semaphore_fork);
! 1818: sem_post(semaphore_gestionnaires_signaux);
! 1819: sem_destroy2(semaphore_gestionnaires_signaux,
! 1820: getpid(), SEM_SIGNAUX);
! 1821: sem_destroy3((*s_etat_processus).semphore_fork,
! 1822: getpid(), pthread_self(), SEM_FORK);
! 1823: # endif
! 1824:
! 1825: liberation_contexte_cas(s_etat_processus);
! 1826: liberation_queue_signaux(s_etat_processus);
! 1827:
! 1828: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1829: stackoverflow_deinstall_handler();
! 1830: # endif
! 1831:
1.1 bertrand 1832: if ((*s_etat_processus).langue == 'F')
1833: {
1834: printf("+++Erreur : option -p présente "
1835: "plus d'une fois\n");
1836: }
1837: else
1838: {
1839: printf("+++Error : more than one -p "
1840: "on command line");
1841: }
1842:
1843: return(EXIT_FAILURE);
1844: }
1845: else if (option_i == d_vrai)
1846: {
1.124 ! bertrand 1847: # ifndef SEMAPHORES_NOMMES
! 1848: sem_post(&((*s_etat_processus).semaphore_fork));
! 1849: sem_post(&semaphore_gestionnaires_signaux);
! 1850: sem_destroy(&semaphore_gestionnaires_signaux);
! 1851: sem_destroy(&((*s_etat_processus)
! 1852: .semaphore_fork));
! 1853: # else
! 1854: sem_post((*s_etat_processus).semaphore_fork);
! 1855: sem_post(semaphore_gestionnaires_signaux);
! 1856: sem_destroy2(semaphore_gestionnaires_signaux,
! 1857: getpid(), SEM_SIGNAUX);
! 1858: sem_destroy3((*s_etat_processus).semphore_fork,
! 1859: getpid(), pthread_self(), SEM_FORK);
! 1860: # endif
! 1861:
! 1862: liberation_contexte_cas(s_etat_processus);
! 1863: liberation_queue_signaux(s_etat_processus);
! 1864:
! 1865: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1866: stackoverflow_deinstall_handler();
! 1867: # endif
! 1868:
1.1 bertrand 1869: if ((*s_etat_processus).langue == 'F')
1870: {
1871: printf("+++Erreur : options -i et -p "
1872: "incompatibles\n");
1873: }
1874: else
1875: {
1876: printf("+++Error : incompatible options -i "
1877: "and -p\n");
1878: }
1879:
1880: return(EXIT_FAILURE);
1881: }
1882:
1883: option_p = d_vrai;
1884:
1885: break;
1886: }
1887:
1888: case 'P' :
1889: {
1890: if (option_P > 2)
1891: {
1.124 ! bertrand 1892: # ifndef SEMAPHORES_NOMMES
! 1893: sem_post(&((*s_etat_processus).semaphore_fork));
! 1894: sem_post(&semaphore_gestionnaires_signaux);
! 1895: sem_destroy(&semaphore_gestionnaires_signaux);
! 1896: sem_destroy(&((*s_etat_processus)
! 1897: .semaphore_fork));
! 1898: # else
! 1899: sem_post((*s_etat_processus).semaphore_fork);
! 1900: sem_post(semaphore_gestionnaires_signaux);
! 1901: sem_destroy2(semaphore_gestionnaires_signaux,
! 1902: getpid(), SEM_SIGNAUX);
! 1903: sem_destroy3((*s_etat_processus).semphore_fork,
! 1904: getpid(), pthread_self(), SEM_FORK);
! 1905: # endif
! 1906:
! 1907: liberation_contexte_cas(s_etat_processus);
! 1908: liberation_queue_signaux(s_etat_processus);
! 1909:
! 1910: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1911: stackoverflow_deinstall_handler();
! 1912: # endif
! 1913:
1.1 bertrand 1914: if ((*s_etat_processus).langue == 'F')
1915: {
1916: printf("+++Erreur : option -P présente "
1917: "plus de deux fois\n");
1918: }
1919: else
1920: {
1921: printf("+++Error : more than two -P "
1922: "on command line");
1923: }
1924:
1925: return(EXIT_FAILURE);
1926: }
1927:
1928: option_P++;
1929:
1930: break;
1931: }
1932:
1933: case 's' :
1934: {
1935: if (option_s == d_vrai)
1936: {
1.124 ! bertrand 1937: # ifndef SEMAPHORES_NOMMES
! 1938: sem_post(&((*s_etat_processus).semaphore_fork));
! 1939: sem_post(&semaphore_gestionnaires_signaux);
! 1940: sem_destroy(&semaphore_gestionnaires_signaux);
! 1941: sem_destroy(&((*s_etat_processus)
! 1942: .semaphore_fork));
! 1943: # else
! 1944: sem_post((*s_etat_processus).semaphore_fork);
! 1945: sem_post(semaphore_gestionnaires_signaux);
! 1946: sem_destroy2(semaphore_gestionnaires_signaux,
! 1947: getpid(), SEM_SIGNAUX);
! 1948: sem_destroy3((*s_etat_processus).semphore_fork,
! 1949: getpid(), pthread_self(), SEM_FORK);
! 1950: # endif
! 1951:
! 1952: liberation_contexte_cas(s_etat_processus);
! 1953: liberation_queue_signaux(s_etat_processus);
! 1954:
! 1955: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 1956: stackoverflow_deinstall_handler();
! 1957: # endif
! 1958:
1.1 bertrand 1959: if ((*s_etat_processus).langue == 'F')
1960: {
1961: printf("+++Erreur : option -s présente "
1962: "plus d'une fois\n");
1963: }
1964: else
1965: {
1966: printf("+++Error : more than one -s "
1967: "on command line");
1968: }
1969:
1970: return(EXIT_FAILURE);
1971: }
1972:
1973: option_s = d_vrai;
1974: drapeau_encart = 'N';
1975: break;
1976: }
1977:
1978: case 'S' :
1979: {
1980: if (option_S == d_vrai)
1981: {
1.124 ! bertrand 1982: # ifndef SEMAPHORES_NOMMES
! 1983: sem_post(&((*s_etat_processus).semaphore_fork));
! 1984: sem_post(&semaphore_gestionnaires_signaux);
! 1985: sem_destroy(&semaphore_gestionnaires_signaux);
! 1986: sem_destroy(&((*s_etat_processus)
! 1987: .semaphore_fork));
! 1988: # else
! 1989: sem_post((*s_etat_processus).semaphore_fork);
! 1990: sem_post(semaphore_gestionnaires_signaux);
! 1991: sem_destroy2(semaphore_gestionnaires_signaux,
! 1992: getpid(), SEM_SIGNAUX);
! 1993: sem_destroy3((*s_etat_processus).semphore_fork,
! 1994: getpid(), pthread_self(), SEM_FORK);
! 1995: # endif
! 1996:
! 1997: liberation_contexte_cas(s_etat_processus);
! 1998: liberation_queue_signaux(s_etat_processus);
! 1999:
! 2000: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2001: stackoverflow_deinstall_handler();
! 2002: # endif
! 2003:
1.1 bertrand 2004: if ((*s_etat_processus).langue == 'F')
2005: {
2006: printf("+++Erreur : option -S présente "
2007: "plus d'une fois\n");
2008: }
2009: else
2010: {
2011: printf("+++Error : more than one -S "
2012: "on command line");
2013: }
2014:
2015: return(EXIT_FAILURE);
2016: }
2017: else if (option_i == d_vrai)
2018: {
1.124 ! bertrand 2019: # ifndef SEMAPHORES_NOMMES
! 2020: sem_post(&((*s_etat_processus).semaphore_fork));
! 2021: sem_post(&semaphore_gestionnaires_signaux);
! 2022: sem_destroy(&semaphore_gestionnaires_signaux);
! 2023: sem_destroy(&((*s_etat_processus)
! 2024: .semaphore_fork));
! 2025: # else
! 2026: sem_post((*s_etat_processus).semaphore_fork);
! 2027: sem_post(semaphore_gestionnaires_signaux);
! 2028: sem_destroy2(semaphore_gestionnaires_signaux,
! 2029: getpid(), SEM_SIGNAUX);
! 2030: sem_destroy3((*s_etat_processus).semphore_fork,
! 2031: getpid(), pthread_self(), SEM_FORK);
! 2032: # endif
! 2033:
! 2034: liberation_contexte_cas(s_etat_processus);
! 2035: liberation_queue_signaux(s_etat_processus);
! 2036:
! 2037: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2038: stackoverflow_deinstall_handler();
! 2039: # endif
! 2040:
1.1 bertrand 2041: if ((*s_etat_processus).langue == 'F')
2042: {
2043: printf("+++Erreur : options -i et -S "
2044: "incompatibles\n");
2045: }
2046: else
2047: {
2048: printf("+++Error : incompatible options -S "
2049: "and -i\n");
2050: }
2051:
2052: return(EXIT_FAILURE);
2053: }
2054:
2055: option_S = d_vrai;
2056:
2057: while(*(++argv[0]) == ' ');
2058: argv[0]--;
2059:
2060: if ((*(++argv[0])) != '\0')
2061: {
2062: if (((*s_etat_processus).definitions_chainees =
2063: malloc((strlen(argv[0]) + 1) *
2064: sizeof(unsigned char))) == NULL)
2065: {
1.124 ! bertrand 2066: # ifndef SEMAPHORES_NOMMES
! 2067: sem_post(&((*s_etat_processus)
! 2068: .semaphore_fork));
! 2069: sem_post(&semaphore_gestionnaires_signaux);
! 2070: sem_destroy(
! 2071: &semaphore_gestionnaires_signaux);
! 2072: sem_destroy(&((*s_etat_processus)
! 2073: .semaphore_fork));
! 2074: # else
! 2075: sem_post((*s_etat_processus)
! 2076: .semaphore_fork);
! 2077: sem_post(semaphore_gestionnaires_signaux);
! 2078: sem_destroy2(
! 2079: semaphore_gestionnaires_signaux,
! 2080: getpid(), SEM_SIGNAUX);
! 2081: sem_destroy3((*s_etat_processus)
! 2082: .semphore_fork, getpid(),
! 2083: pthread_self(), SEM_FORK);
! 2084: # endif
! 2085:
! 2086: liberation_contexte_cas(s_etat_processus);
! 2087: liberation_queue_signaux(s_etat_processus);
! 2088:
! 2089: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2090: stackoverflow_deinstall_handler();
! 2091: # endif
! 2092:
1.1 bertrand 2093: if ((*s_etat_processus).langue == 'F')
2094: {
2095: printf("+++Système : Mémoire "
2096: "insuffisante\n");
2097: }
2098: else
2099: {
2100: printf("+++System : Not enough "
2101: "memory\n");
2102: }
2103:
2104: return(EXIT_FAILURE);
2105: }
2106:
2107: ptr = (*s_etat_processus).definitions_chainees;
2108:
2109: while(*(argv[0]) != '\0')
2110: {
2111: *(ptr++) = *(argv[0]++);
2112: }
2113:
2114: (*ptr) = '\0';
2115:
2116: argv[0]--;
2117: presence_definition = 'O';
2118: }
2119: else if ((--argc) > 0)
2120: {
2121: argv++;
2122:
2123: if (((*s_etat_processus).definitions_chainees =
2124: malloc((strlen(argv[0]) + 1) *
2125: sizeof(unsigned char))) == NULL)
2126: {
1.124 ! bertrand 2127: # ifndef SEMAPHORES_NOMMES
! 2128: sem_post(&((*s_etat_processus)
! 2129: .semaphore_fork));
! 2130: sem_post(&semaphore_gestionnaires_signaux);
! 2131: sem_destroy(
! 2132: &semaphore_gestionnaires_signaux);
! 2133: sem_destroy(&((*s_etat_processus)
! 2134: .semaphore_fork));
! 2135: # else
! 2136: sem_post((*s_etat_processus)
! 2137: .semaphore_fork);
! 2138: sem_post(semaphore_gestionnaires_signaux);
! 2139: sem_destroy2(
! 2140: semaphore_gestionnaires_signaux,
! 2141: getpid(), SEM_SIGNAUX);
! 2142: sem_destroy3((*s_etat_processus)
! 2143: .semphore_fork, getpid(),
! 2144: pthread_self(), SEM_FORK);
! 2145: # endif
! 2146:
! 2147: liberation_contexte_cas(s_etat_processus);
! 2148: liberation_queue_signaux(s_etat_processus);
! 2149:
! 2150: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2151: stackoverflow_deinstall_handler();
! 2152: # endif
! 2153:
1.1 bertrand 2154: if ((*s_etat_processus).langue == 'F')
2155: {
2156: printf("+++Système : Mémoire "
2157: "insuffisante\n");
2158: }
2159: else
2160: {
2161: printf("+++System : Not enough "
2162: "memory\n");
2163: }
2164:
2165: return(EXIT_FAILURE);
2166: }
2167:
2168: ptr = (*s_etat_processus).definitions_chainees;
2169:
2170: while(*(argv[0]) != '\0')
2171: {
2172: *(ptr++) = *(argv[0]++);
2173: }
2174:
2175: (*ptr) = '\0';
2176:
2177: argv[0]--;
2178: presence_definition = 'O';
2179: }
2180: else
2181: {
1.124 ! bertrand 2182: # ifndef SEMAPHORES_NOMMES
! 2183: sem_post(&((*s_etat_processus).semaphore_fork));
! 2184: sem_post(&semaphore_gestionnaires_signaux);
! 2185: sem_destroy(&semaphore_gestionnaires_signaux);
! 2186: sem_destroy(&((*s_etat_processus)
! 2187: .semaphore_fork));
! 2188: # else
! 2189: sem_post((*s_etat_processus).semaphore_fork);
! 2190: sem_post(semaphore_gestionnaires_signaux);
! 2191: sem_destroy2(semaphore_gestionnaires_signaux,
! 2192: getpid(), SEM_SIGNAUX);
! 2193: sem_destroy3((*s_etat_processus).semphore_fork,
! 2194: getpid(), pthread_self(), SEM_FORK);
! 2195: # endif
! 2196:
! 2197: liberation_contexte_cas(s_etat_processus);
! 2198: liberation_queue_signaux(s_etat_processus);
! 2199:
! 2200: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2201: stackoverflow_deinstall_handler();
! 2202: # endif
! 2203:
1.1 bertrand 2204: if ((*s_etat_processus).langue == 'F')
2205: {
2206: printf("+++Erreur : Aucun script "
2207: "spécifié après l'option -S\n");
2208: }
2209: else
2210: {
2211: printf("+++Error : Script required after "
2212: "-S option\n");
2213: }
2214:
2215: return(EXIT_FAILURE);
2216: }
2217:
2218: if (((*s_etat_processus).definitions_chainees =
2219: compactage((*s_etat_processus)
2220: .definitions_chainees)) == NULL)
2221: {
1.124 ! bertrand 2222: # ifndef SEMAPHORES_NOMMES
! 2223: sem_post(&((*s_etat_processus).semaphore_fork));
! 2224: sem_post(&semaphore_gestionnaires_signaux);
! 2225: sem_destroy(&semaphore_gestionnaires_signaux);
! 2226: sem_destroy(&((*s_etat_processus)
! 2227: .semaphore_fork));
! 2228: # else
! 2229: sem_post((*s_etat_processus).semaphore_fork);
! 2230: sem_post(semaphore_gestionnaires_signaux);
! 2231: sem_destroy2(semaphore_gestionnaires_signaux,
! 2232: getpid(), SEM_SIGNAUX);
! 2233: sem_destroy3((*s_etat_processus).semphore_fork,
! 2234: getpid(), pthread_self(), SEM_FORK);
! 2235: # endif
! 2236:
! 2237: liberation_contexte_cas(s_etat_processus);
! 2238: liberation_queue_signaux(s_etat_processus);
! 2239:
! 2240: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2241: stackoverflow_deinstall_handler();
! 2242: # endif
! 2243:
1.1 bertrand 2244: if ((*s_etat_processus).langue == 'F')
2245: {
2246: printf("+++Système : Mémoire "
2247: "insuffisante\n");
2248: }
2249: else
2250: {
2251: printf("+++System : Not enough "
2252: "memory\n");
2253: }
2254:
2255: return(EXIT_FAILURE);
2256: }
2257:
2258: (*s_etat_processus).longueur_definitions_chainees =
2259: strlen((*s_etat_processus)
2260: .definitions_chainees);
2261:
2262: break;
2263: }
2264:
2265: case 't' :
2266: {
2267: if (option_t == d_vrai)
2268: {
1.124 ! bertrand 2269: # ifndef SEMAPHORES_NOMMES
! 2270: sem_post(&((*s_etat_processus).semaphore_fork));
! 2271: sem_post(&semaphore_gestionnaires_signaux);
! 2272: sem_destroy(&semaphore_gestionnaires_signaux);
! 2273: sem_destroy(&((*s_etat_processus)
! 2274: .semaphore_fork));
! 2275: # else
! 2276: sem_post((*s_etat_processus).semaphore_fork);
! 2277: sem_post(semaphore_gestionnaires_signaux);
! 2278: sem_destroy2(semaphore_gestionnaires_signaux,
! 2279: getpid(), SEM_SIGNAUX);
! 2280: sem_destroy3((*s_etat_processus).semphore_fork,
! 2281: getpid(), pthread_self(), SEM_FORK);
! 2282: # endif
! 2283:
! 2284: liberation_contexte_cas(s_etat_processus);
! 2285: liberation_queue_signaux(s_etat_processus);
! 2286:
! 2287: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2288: stackoverflow_deinstall_handler();
! 2289: # endif
! 2290:
1.1 bertrand 2291: if ((*s_etat_processus).langue == 'F')
2292: {
2293: printf("+++Erreur : option -t présente "
2294: "plus d'une fois\n");
2295: }
2296: else
2297: {
2298: printf("+++Error : more than one -t "
2299: "on command line");
2300: }
2301:
2302: return(EXIT_FAILURE);
2303: }
2304:
2305: option_t = d_vrai;
2306: (*s_etat_processus).debug = d_vrai;
2307:
2308: while(*(++argv[0]) == ' ');
2309: argv[0]--;
2310:
2311: if ((*(++argv[0])) != '\0')
2312: {
2313: if ((type_debug = malloc((strlen(argv[0]) + 1) *
2314: sizeof(unsigned char))) == NULL)
2315: {
1.124 ! bertrand 2316: # ifndef SEMAPHORES_NOMMES
! 2317: sem_post(&((*s_etat_processus)
! 2318: .semaphore_fork));
! 2319: sem_post(&semaphore_gestionnaires_signaux);
! 2320: sem_destroy(
! 2321: &semaphore_gestionnaires_signaux);
! 2322: sem_destroy(&((*s_etat_processus)
! 2323: .semaphore_fork));
! 2324: # else
! 2325: sem_post((*s_etat_processus)
! 2326: .semaphore_fork);
! 2327: sem_post(semaphore_gestionnaires_signaux);
! 2328: sem_destroy2(
! 2329: semaphore_gestionnaires_signaux,
! 2330: getpid(), SEM_SIGNAUX);
! 2331: sem_destroy3((*s_etat_processus)
! 2332: .semphore_fork, getpid(),
! 2333: pthread_self(), SEM_FORK);
! 2334: # endif
! 2335:
! 2336: liberation_contexte_cas(s_etat_processus);
! 2337: liberation_queue_signaux(s_etat_processus);
! 2338:
! 2339: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2340: stackoverflow_deinstall_handler();
! 2341: # endif
! 2342:
1.1 bertrand 2343: if ((*s_etat_processus).langue == 'F')
2344: {
2345: printf("+++Système : Mémoire "
2346: "insuffisante\n");
2347: }
2348: else
2349: {
2350: printf("+++System : Not enough "
2351: "memory\n");
2352: }
2353:
2354: return(EXIT_FAILURE);
2355: }
2356:
2357: ptr = type_debug;
2358:
2359: while((*(argv[0]) != '\0') &&
2360: (*(argv[0]) != ' '))
2361: {
2362: *(ptr++) = *(argv[0]++);
2363: }
2364:
2365: (*ptr) = '\0';
2366:
2367: argv[0]--;
2368: }
2369: else if ((--argc) > 0)
2370: {
2371: argv++;
2372:
2373: if ((type_debug =
2374: malloc((strlen(argv[0]) + 1) *
2375: sizeof(unsigned char))) == NULL)
2376: {
1.124 ! bertrand 2377: # ifndef SEMAPHORES_NOMMES
! 2378: sem_post(&((*s_etat_processus)
! 2379: .semaphore_fork));
! 2380: sem_post(&semaphore_gestionnaires_signaux);
! 2381: sem_destroy(
! 2382: &semaphore_gestionnaires_signaux);
! 2383: sem_destroy(&((*s_etat_processus)
! 2384: .semaphore_fork));
! 2385: # else
! 2386: sem_post((*s_etat_processus)
! 2387: .semaphore_fork);
! 2388: sem_post(semaphore_gestionnaires_signaux);
! 2389: sem_destroy2(
! 2390: semaphore_gestionnaires_signaux,
! 2391: getpid(), SEM_SIGNAUX);
! 2392: sem_destroy3((*s_etat_processus)
! 2393: .semphore_fork, getpid(),
! 2394: pthread_self(), SEM_FORK);
! 2395: # endif
! 2396:
! 2397: liberation_contexte_cas(s_etat_processus);
! 2398: liberation_queue_signaux(s_etat_processus);
! 2399:
! 2400: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2401: stackoverflow_deinstall_handler();
! 2402: # endif
! 2403:
1.1 bertrand 2404: if ((*s_etat_processus).langue == 'F')
2405: {
2406: printf("+++Système : Mémoire "
2407: "insuffisante\n");
2408: }
2409: else
2410: {
2411: printf("+++System : Not enough "
2412: "memory\n");
2413: }
2414:
2415: return(EXIT_FAILURE);
2416: }
2417:
2418: ptr = type_debug;
2419:
2420: while(*(argv[0]) != '\0')
2421: {
2422: *(ptr++) = *(argv[0]++);
2423: }
2424:
2425: (*ptr) = '\0';
2426:
2427: argv[0]--;
2428: }
2429: else
2430: {
1.124 ! bertrand 2431: # ifndef SEMAPHORES_NOMMES
! 2432: sem_post(&((*s_etat_processus).semaphore_fork));
! 2433: sem_post(&semaphore_gestionnaires_signaux);
! 2434: sem_destroy(&semaphore_gestionnaires_signaux);
! 2435: sem_destroy(&((*s_etat_processus)
! 2436: .semaphore_fork));
! 2437: # else
! 2438: sem_post((*s_etat_processus).semaphore_fork);
! 2439: sem_post(semaphore_gestionnaires_signaux);
! 2440: sem_destroy2(semaphore_gestionnaires_signaux,
! 2441: getpid(), SEM_SIGNAUX);
! 2442: sem_destroy3((*s_etat_processus).semphore_fork,
! 2443: getpid(), pthread_self(), SEM_FORK);
! 2444: # endif
! 2445:
! 2446: liberation_contexte_cas(s_etat_processus);
! 2447: liberation_queue_signaux(s_etat_processus);
! 2448:
! 2449: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2450: stackoverflow_deinstall_handler();
! 2451: # endif
! 2452:
1.1 bertrand 2453: if ((*s_etat_processus).langue == 'F')
2454: {
2455: printf("+++Erreur : Aucun niveau "
2456: "de débogage spécifié après "
2457: "l'option -t\n");
2458: }
2459: else
2460: {
2461: printf("+++Error : Debug level not "
2462: "specified after -t option\n");
2463: }
2464:
2465: return(EXIT_FAILURE);
2466: }
2467:
2468: ptr = type_debug;
2469:
2470: while(*ptr != '\0')
2471: {
2472: switch(*ptr)
2473: {
2474: case '0':
2475: case '1':
2476: case '2':
2477: case '3':
2478: case '4':
2479: case '5':
2480: case '6':
2481: case '7':
2482: case '8':
2483: case '9':
2484: case 'A':
2485: case 'B':
2486: case 'C':
2487: case 'D':
2488: case 'E':
2489: case 'F':
2490: {
2491: break;
2492: }
2493:
2494: default:
2495: {
1.124 ! bertrand 2496: # ifndef SEMAPHORES_NOMMES
! 2497: sem_post(&((*s_etat_processus)
! 2498: .semaphore_fork));
! 2499: sem_post(
! 2500: &semaphore_gestionnaires_signaux
! 2501: );
! 2502: sem_destroy(
! 2503: &semaphore_gestionnaires_signaux
! 2504: );
! 2505: sem_destroy(&((*s_etat_processus)
! 2506: .semaphore_fork));
! 2507: # else
! 2508: sem_post((*s_etat_processus)
! 2509: .semaphore_fork);
! 2510: sem_post(
! 2511: semaphore_gestionnaires_signaux
! 2512: );
! 2513: sem_destroy2(
! 2514: semaphore_gestionnaires_signaux,
! 2515: getpid(), SEM_SIGNAUX);
! 2516: sem_destroy3((*s_etat_processus)
! 2517: .semphore_fork, getpid(),
! 2518: pthread_self(), SEM_FORK);
! 2519: # endif
! 2520:
! 2521: liberation_contexte_cas(
! 2522: s_etat_processus);
! 2523: liberation_queue_signaux(
! 2524: s_etat_processus);
! 2525:
! 2526: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2527: stackoverflow_deinstall_handler();
! 2528: # endif
! 2529:
1.1 bertrand 2530: if ((*s_etat_processus).langue == 'F')
2531: {
2532: printf("+++Erreur : Niveau "
2533: "de débogage non "
2534: "hexadécimal\n");
2535: }
2536: else
2537: {
2538: printf("+++Error : Debug level must"
2539: " be hexadecimal "
2540: "integer\n");
2541: }
2542:
2543: return(EXIT_FAILURE);
2544: }
2545: }
2546:
2547: ptr++;
2548: }
2549:
2550: if (sscanf(type_debug, "%llX",
2551: &((*s_etat_processus).type_debug)) != 1)
2552: {
1.124 ! bertrand 2553: # ifndef SEMAPHORES_NOMMES
! 2554: sem_post(&((*s_etat_processus).semaphore_fork));
! 2555: sem_post(&semaphore_gestionnaires_signaux);
! 2556: sem_destroy(&semaphore_gestionnaires_signaux);
! 2557: sem_destroy(&((*s_etat_processus)
! 2558: .semaphore_fork));
! 2559: # else
! 2560: sem_post((*s_etat_processus).semaphore_fork);
! 2561: sem_post(semaphore_gestionnaires_signaux);
! 2562: sem_destroy2(semaphore_gestionnaires_signaux,
! 2563: getpid(), SEM_SIGNAUX);
! 2564: sem_destroy3((*s_etat_processus).semphore_fork,
! 2565: getpid(), pthread_self(), SEM_FORK);
! 2566: # endif
! 2567:
! 2568: liberation_contexte_cas(s_etat_processus);
! 2569: liberation_queue_signaux(s_etat_processus);
! 2570:
! 2571: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2572: stackoverflow_deinstall_handler();
! 2573: # endif
! 2574:
1.1 bertrand 2575: if ((*s_etat_processus).langue == 'F')
2576: {
2577: printf("+++Erreur : Niveau "
2578: "de débogage non entier\n");
2579: }
2580: else
2581: {
2582: printf("+++Error : Debug level must"
2583: " be integer\n");
2584: }
2585:
2586: return(EXIT_FAILURE);
2587: }
2588:
1.17 bertrand 2589: free(type_debug);
1.1 bertrand 2590: break;
2591: }
2592:
2593: case 'v' :
2594: {
2595: if (option_v == d_vrai)
2596: {
1.124 ! bertrand 2597: # ifndef SEMAPHORES_NOMMES
! 2598: sem_post(&((*s_etat_processus).semaphore_fork));
! 2599: sem_post(&semaphore_gestionnaires_signaux);
! 2600: sem_destroy(&semaphore_gestionnaires_signaux);
! 2601: sem_destroy(&((*s_etat_processus)
! 2602: .semaphore_fork));
! 2603: # else
! 2604: sem_post((*s_etat_processus).semaphore_fork);
! 2605: sem_post(semaphore_gestionnaires_signaux);
! 2606: sem_destroy2(semaphore_gestionnaires_signaux,
! 2607: getpid(), SEM_SIGNAUX);
! 2608: sem_destroy3((*s_etat_processus).semphore_fork,
! 2609: getpid(), pthread_self(), SEM_FORK);
! 2610: # endif
! 2611:
! 2612: liberation_contexte_cas(s_etat_processus);
! 2613: liberation_queue_signaux(s_etat_processus);
! 2614:
! 2615: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2616: stackoverflow_deinstall_handler();
! 2617: # endif
! 2618:
1.1 bertrand 2619: if ((*s_etat_processus).langue == 'F')
2620: {
2621: printf("+++Erreur : option -v présente "
2622: "plus d'une fois\n");
2623: }
2624: else
2625: {
2626: printf("+++Error : more than one -v "
2627: "on command line");
2628: }
2629:
2630: return(EXIT_FAILURE);
2631: }
2632:
2633: option_v = d_vrai;
2634: printf("\n");
2635:
2636: if ((*s_etat_processus).langue == 'F')
2637: {
2638: printf(" Reverse Polish Lisp/2 version %s "
2639: "pour systèmes "
2640: "POSIX\n", d_version_rpl);
2641: printf(" Langage procédural de très haut "
2642: "niveau, semi-compilé, "
2643: "extensible,\n");
2644: printf(" destiné principalement aux "
2645: "calculs scientifiques et "
2646: "symboliques\n");
2647: printf("%s\n", copyright);
2648: }
2649: else
2650: {
2651: printf(" Reverse Polish Lisp/2 version %s "
2652: "for POSIX operating systems\n",
2653: d_version_rpl);
2654: printf(" Half-compiled, high-level "
2655: "procedural language,\n");
2656: printf(" mainly aiming at scientific "
2657: "calculations\n");
2658: printf("%s\n", copyright_anglais);
2659: }
2660:
2661: printf("\n");
2662: break;
2663: }
2664:
1.86 bertrand 2665: case '-':
2666: case ' ':
2667: {
2668: break;
2669: }
2670:
1.1 bertrand 2671: default :
2672: {
2673: if ((*s_etat_processus).langue == 'F')
2674: {
1.3 bertrand 2675: printf("+++Information : Option -%c inconnue\n",
1.1 bertrand 2676: option);
2677: }
2678: else
2679: {
1.3 bertrand 2680: printf("+++Warning : -%c option unknown\n",
1.1 bertrand 2681: option);
2682: }
2683:
2684: informations(s_etat_processus);
2685: break;
2686: }
2687: }
2688: }
2689: }
2690: else
2691: {
2692: if (presence_definition == 'O')
2693: {
2694: argc = 0;
2695:
2696: if ((*s_etat_processus).langue == 'F')
2697: {
2698: printf("+++Erreur : Plusieurs définitions\n");
2699: }
2700: else
2701: {
2702: printf("+++Error : More than one definition\n");
2703: }
2704:
1.13 bertrand 2705: erreur = d_erreur;
1.1 bertrand 2706: }
2707: else
2708: {
2709: (*s_etat_processus).nom_fichier_source = argv[0];
2710: presence_definition = 'O';
2711: }
2712: }
2713: }
2714:
1.94 bertrand 2715: /*
2716: * Dans le cas où le programme est appelé avec l'option -d,
2717: * on ne récupère par les signaux de violation d'accès. On
2718: * tente simplement la récupération des dépassements de pile.
2719: */
2720:
1.1 bertrand 2721: if (debug == d_faux)
2722: {
1.94 bertrand 2723: # ifdef HAVE_SIGSEGV_RECOVERY
2724: if (sigsegv_install_handler(interruption_violation_access) != 0)
2725: {
1.124 ! bertrand 2726: # ifndef SEMAPHORES_NOMMES
! 2727: sem_post(&((*s_etat_processus).semaphore_fork));
! 2728: sem_post(&semaphore_gestionnaires_signaux);
! 2729: sem_destroy(&semaphore_gestionnaires_signaux);
! 2730: sem_destroy(&((*s_etat_processus)
! 2731: .semaphore_fork));
! 2732: # else
! 2733: sem_post((*s_etat_processus).semaphore_fork);
! 2734: sem_post(semaphore_gestionnaires_signaux);
! 2735: sem_destroy2(semaphore_gestionnaires_signaux,
! 2736: getpid(), SEM_SIGNAUX);
! 2737: sem_destroy3((*s_etat_processus).semphore_fork,
! 2738: getpid(), pthread_self(), SEM_FORK);
! 2739: # endif
! 2740:
! 2741: liberation_contexte_cas(s_etat_processus);
! 2742: liberation_queue_signaux(s_etat_processus);
! 2743:
! 2744: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2745: stackoverflow_deinstall_handler();
! 2746: # endif
! 2747:
1.94 bertrand 2748: erreur = d_es_signal;
2749:
2750: if ((*s_etat_processus).langue == 'F')
2751: {
2752: printf("+++Système : Initialisation de la pile alternative "
2753: "impossible\n");
2754: }
2755: else
2756: {
2757: printf("+++System : Initialization of alternate "
2758: "stack failed\n");
2759: }
2760:
2761: return(EXIT_FAILURE);
2762: }
2763: # else
1.82 bertrand 2764: action.sa_handler = interruption3;
1.94 bertrand 2765: action.sa_flags = 0;
1.82 bertrand 2766:
1.1 bertrand 2767: if (sigaction(SIGSEGV, &action, NULL) != 0)
2768: {
1.124 ! bertrand 2769: # ifndef SEMAPHORES_NOMMES
! 2770: sem_post(&((*s_etat_processus).semaphore_fork));
! 2771: sem_post(&semaphore_gestionnaires_signaux);
! 2772: sem_destroy(&semaphore_gestionnaires_signaux);
! 2773: sem_destroy(&((*s_etat_processus)
! 2774: .semaphore_fork));
! 2775: # else
! 2776: sem_post((*s_etat_processus).semaphore_fork);
! 2777: sem_post(semaphore_gestionnaires_signaux);
! 2778: sem_destroy2(semaphore_gestionnaires_signaux,
! 2779: getpid(), SEM_SIGNAUX);
! 2780: sem_destroy3((*s_etat_processus).semphore_fork,
! 2781: getpid(), pthread_self(), SEM_FORK);
! 2782: # endif
! 2783:
! 2784: liberation_contexte_cas(s_etat_processus);
! 2785: liberation_queue_signaux(s_etat_processus);
! 2786:
! 2787: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2788: stackoverflow_deinstall_handler();
! 2789: # endif
! 2790:
1.1 bertrand 2791: if ((*s_etat_processus).langue == 'F')
2792: {
2793: printf("+++Système : Initialisation des signaux POSIX "
2794: "impossible\n");
2795: }
2796: else
2797: {
2798: printf("+++System : Initialization of POSIX signals "
2799: "failed\n");
2800: }
2801:
2802: return(EXIT_FAILURE);
2803: }
2804:
1.94 bertrand 2805: signal_test = SIGTEST;
2806: kill(getpid(), SIGSEGV);
2807:
1.115 bertrand 2808: attente.tv_sec = 0;
2809: attente.tv_nsec = 1000000;
2810:
2811: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
2812: {
2813: nanosleep(&attente, NULL);
2814: }
2815:
1.94 bertrand 2816: if (signal_test != SIGSEGV)
2817: {
1.124 ! bertrand 2818: # ifndef SEMAPHORES_NOMMES
! 2819: sem_post(&((*s_etat_processus).semaphore_fork));
! 2820: sem_post(&semaphore_gestionnaires_signaux);
! 2821: sem_destroy(&semaphore_gestionnaires_signaux);
! 2822: sem_destroy(&((*s_etat_processus)
! 2823: .semaphore_fork));
! 2824: # else
! 2825: sem_post((*s_etat_processus).semaphore_fork);
! 2826: sem_post(semaphore_gestionnaires_signaux);
! 2827: sem_destroy2(semaphore_gestionnaires_signaux,
! 2828: getpid(), SEM_SIGNAUX);
! 2829: sem_destroy3((*s_etat_processus).semphore_fork,
! 2830: getpid(), pthread_self(), SEM_FORK);
! 2831: # endif
! 2832:
! 2833: liberation_contexte_cas(s_etat_processus);
! 2834: liberation_queue_signaux(s_etat_processus);
! 2835:
! 2836: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2837: stackoverflow_deinstall_handler();
! 2838: # endif
! 2839:
1.94 bertrand 2840: erreur = d_es_signal;
2841:
2842: if ((*s_etat_processus).langue == 'F')
2843: {
2844: printf("+++Système : Initialisation des signaux POSIX "
2845: "impossible\n");
2846: }
2847: else
2848: {
2849: printf("+++System : Initialization of POSIX signals "
2850: "failed\n");
2851: }
2852:
2853: return(EXIT_FAILURE);
2854: }
2855: # endif
2856:
1.115 bertrand 2857: action.sa_handler = interruption3;
2858: action.sa_flags = 0;
2859:
1.1 bertrand 2860: if (sigaction(SIGBUS, &action, NULL) != 0)
2861: {
1.124 ! bertrand 2862: # ifndef SEMAPHORES_NOMMES
! 2863: sem_post(&((*s_etat_processus).semaphore_fork));
! 2864: sem_post(&semaphore_gestionnaires_signaux);
! 2865: sem_destroy(&semaphore_gestionnaires_signaux);
! 2866: sem_destroy(&((*s_etat_processus)
! 2867: .semaphore_fork));
! 2868: # else
! 2869: sem_post((*s_etat_processus).semaphore_fork);
! 2870: sem_post(semaphore_gestionnaires_signaux);
! 2871: sem_destroy2(semaphore_gestionnaires_signaux,
! 2872: getpid(), SEM_SIGNAUX);
! 2873: sem_destroy3((*s_etat_processus).semphore_fork,
! 2874: getpid(), pthread_self(), SEM_FORK);
! 2875: # endif
! 2876:
! 2877: liberation_contexte_cas(s_etat_processus);
! 2878: liberation_queue_signaux(s_etat_processus);
! 2879:
! 2880: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2881: stackoverflow_deinstall_handler();
! 2882: # endif
! 2883:
! 2884: # ifdef HAVE_SIGSEGV_RECOVERY
! 2885: if (debug == d_faux)
! 2886: {
! 2887: sigsegv_deinstall_handler();
! 2888: }
! 2889: # endif
! 2890:
1.1 bertrand 2891: if ((*s_etat_processus).langue == 'F')
2892: {
2893: printf("+++Système : Initialisation des signaux POSIX "
2894: "impossible\n");
2895: }
2896: else
2897: {
2898: printf("+++System : Initialization of POSIX signals "
2899: "failed\n");
2900: }
2901:
2902: return(EXIT_FAILURE);
2903: }
1.94 bertrand 2904:
2905: signal_test = SIGTEST;
2906: kill(getpid(), SIGBUS);
2907:
1.115 bertrand 2908: attente.tv_sec = 0;
2909: attente.tv_nsec = 1000000;
2910:
2911: for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
2912: {
2913: nanosleep(&attente, NULL);
2914: }
2915:
1.94 bertrand 2916: if (signal_test != SIGBUS)
2917: {
1.124 ! bertrand 2918: # ifndef SEMAPHORES_NOMMES
! 2919: sem_post(&((*s_etat_processus).semaphore_fork));
! 2920: sem_post(&semaphore_gestionnaires_signaux);
! 2921: sem_destroy(&semaphore_gestionnaires_signaux);
! 2922: sem_destroy(&((*s_etat_processus)
! 2923: .semaphore_fork));
! 2924: # else
! 2925: sem_post((*s_etat_processus).semaphore_fork);
! 2926: sem_post(semaphore_gestionnaires_signaux);
! 2927: sem_destroy2(semaphore_gestionnaires_signaux,
! 2928: getpid(), SEM_SIGNAUX);
! 2929: sem_destroy3((*s_etat_processus).semphore_fork,
! 2930: getpid(), pthread_self(), SEM_FORK);
! 2931: # endif
! 2932:
! 2933: liberation_contexte_cas(s_etat_processus);
! 2934: liberation_queue_signaux(s_etat_processus);
! 2935:
! 2936: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2937: stackoverflow_deinstall_handler();
! 2938: # endif
! 2939:
! 2940: # ifdef HAVE_SIGSEGV_RECOVERY
! 2941: if (debug == d_faux)
! 2942: {
! 2943: sigsegv_deinstall_handler();
! 2944: }
! 2945: # endif
! 2946:
1.94 bertrand 2947: erreur = d_es_signal;
2948:
2949: if ((*s_etat_processus).langue == 'F')
2950: {
2951: printf("+++Système : Initialisation des signaux POSIX "
2952: "impossible\n");
2953: }
2954: else
2955: {
2956: printf("+++System : Initialization of POSIX signals "
2957: "failed\n");
2958: }
2959:
2960: return(EXIT_FAILURE);
2961: }
2962:
1.1 bertrand 2963: }
2964:
2965: if (option_n == d_vrai)
2966: {
1.83 bertrand 2967: action.sa_handler = interruption4;
1.94 bertrand 2968: action.sa_flags = 0;
1.1 bertrand 2969:
2970: if (sigaction(SIGHUP, &action, NULL) != 0)
2971: {
1.124 ! bertrand 2972: # ifndef SEMAPHORES_NOMMES
! 2973: sem_post(&((*s_etat_processus).semaphore_fork));
! 2974: sem_post(&semaphore_gestionnaires_signaux);
! 2975: sem_destroy(&semaphore_gestionnaires_signaux);
! 2976: sem_destroy(&((*s_etat_processus)
! 2977: .semaphore_fork));
! 2978: # else
! 2979: sem_post((*s_etat_processus).semaphore_fork);
! 2980: sem_post(semaphore_gestionnaires_signaux);
! 2981: sem_destroy2(semaphore_gestionnaires_signaux,
! 2982: getpid(), SEM_SIGNAUX);
! 2983: sem_destroy3((*s_etat_processus).semphore_fork,
! 2984: getpid(), pthread_self(), SEM_FORK);
! 2985: # endif
! 2986:
! 2987: liberation_contexte_cas(s_etat_processus);
! 2988: liberation_queue_signaux(s_etat_processus);
! 2989:
! 2990: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 2991: stackoverflow_deinstall_handler();
! 2992: # endif
! 2993:
! 2994: # ifdef HAVE_SIGSEGV_RECOVERY
! 2995: if (debug == d_faux)
! 2996: {
! 2997: sigsegv_deinstall_handler();
! 2998: }
! 2999: # endif
! 3000:
1.1 bertrand 3001: if ((*s_etat_processus).langue == 'F')
3002: {
3003: printf("+++Système : Initialisation des signaux POSIX "
3004: "impossible\n");
3005: }
3006: else
3007: {
3008: printf("+++System : Initialization of POSIX signals "
3009: "failed\n");
3010: }
3011:
3012: return(EXIT_FAILURE);
3013: }
3014: }
3015:
3016: if (mode_interactif == d_vrai)
3017: {
3018: printf("\n");
3019:
3020: if ((*s_etat_processus).langue == 'F')
3021: {
3022: printf("+++Ce logiciel est un logiciel libre"
3023: " sans aucune garantie de "
3024: "fonctionnement.\n");
3025: printf("+++Pour plus de détails, utilisez la "
3026: "commande 'warranty'.\n");
3027: }
3028: else
3029: {
3030: printf("+++This is a free software with "
3031: "absolutely no warranty.\n");
3032: printf("+++For details, type 'warranty'.\n");
3033: }
3034:
3035: printf("\n");
3036:
3037: traitement_fichier_temporaire = 'Y';
3038:
3039: if ((nom_fichier_temporaire =
3040: creation_nom_fichier(s_etat_processus, (*s_etat_processus)
3041: .chemin_fichiers_temporaires)) == NULL)
3042: {
1.124 ! bertrand 3043: # ifndef SEMAPHORES_NOMMES
! 3044: sem_post(&((*s_etat_processus).semaphore_fork));
! 3045: sem_post(&semaphore_gestionnaires_signaux);
! 3046: sem_destroy(&semaphore_gestionnaires_signaux);
! 3047: sem_destroy(&((*s_etat_processus)
! 3048: .semaphore_fork));
! 3049: # else
! 3050: sem_post((*s_etat_processus).semaphore_fork);
! 3051: sem_post(semaphore_gestionnaires_signaux);
! 3052: sem_destroy2(semaphore_gestionnaires_signaux,
! 3053: getpid(), SEM_SIGNAUX);
! 3054: sem_destroy3((*s_etat_processus).semphore_fork,
! 3055: getpid(), pthread_self(), SEM_FORK);
! 3056: # endif
! 3057:
! 3058: liberation_contexte_cas(s_etat_processus);
! 3059: liberation_queue_signaux(s_etat_processus);
! 3060:
! 3061: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3062: stackoverflow_deinstall_handler();
! 3063: # endif
! 3064:
! 3065: # ifdef HAVE_SIGSEGV_RECOVERY
! 3066: if (debug == d_faux)
! 3067: {
! 3068: sigsegv_deinstall_handler();
! 3069: }
! 3070: # endif
! 3071:
1.1 bertrand 3072: if ((*s_etat_processus).langue == 'F')
3073: {
3074: printf("+++Système : Fichier indisponible\n");
3075: }
3076: else
3077: {
3078: printf("+++System : File unavailable\n");
3079: }
3080:
3081: return(EXIT_FAILURE);
3082: }
3083:
3084: if ((f_source = fopen(nom_fichier_temporaire, "w"))
3085: == NULL)
3086: {
1.124 ! bertrand 3087: # ifndef SEMAPHORES_NOMMES
! 3088: sem_post(&((*s_etat_processus).semaphore_fork));
! 3089: sem_post(&semaphore_gestionnaires_signaux);
! 3090: sem_destroy(&semaphore_gestionnaires_signaux);
! 3091: sem_destroy(&((*s_etat_processus)
! 3092: .semaphore_fork));
! 3093: # else
! 3094: sem_post((*s_etat_processus).semaphore_fork);
! 3095: sem_post(semaphore_gestionnaires_signaux);
! 3096: sem_destroy2(semaphore_gestionnaires_signaux,
! 3097: getpid(), SEM_SIGNAUX);
! 3098: sem_destroy3((*s_etat_processus).semphore_fork,
! 3099: getpid(), pthread_self(), SEM_FORK);
! 3100: # endif
! 3101:
! 3102: liberation_contexte_cas(s_etat_processus);
! 3103: liberation_queue_signaux(s_etat_processus);
! 3104:
! 3105: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3106: stackoverflow_deinstall_handler();
! 3107: # endif
! 3108:
! 3109: # ifdef HAVE_SIGSEGV_RECOVERY
! 3110: if (debug == d_faux)
! 3111: {
! 3112: sigsegv_deinstall_handler();
! 3113: }
! 3114: # endif
! 3115:
1.1 bertrand 3116: if ((*s_etat_processus).langue == 'F')
3117: {
3118: printf("+++Système : Fichier introuvable\n");
3119: }
3120: else
3121: {
3122: printf("+++System : File not found\n");
3123: }
3124:
3125: return(EXIT_FAILURE);
3126: }
3127:
3128: if (fprintf(f_source, "MODE_INTERACTIF\n") < 0)
3129: {
1.124 ! bertrand 3130: # ifndef SEMAPHORES_NOMMES
! 3131: sem_post(&((*s_etat_processus).semaphore_fork));
! 3132: sem_post(&semaphore_gestionnaires_signaux);
! 3133: sem_destroy(&semaphore_gestionnaires_signaux);
! 3134: sem_destroy(&((*s_etat_processus)
! 3135: .semaphore_fork));
! 3136: # else
! 3137: sem_post((*s_etat_processus).semaphore_fork);
! 3138: sem_post(semaphore_gestionnaires_signaux);
! 3139: sem_destroy2(semaphore_gestionnaires_signaux,
! 3140: getpid(), SEM_SIGNAUX);
! 3141: sem_destroy3((*s_etat_processus).semphore_fork,
! 3142: getpid(), pthread_self(), SEM_FORK);
! 3143: # endif
! 3144:
! 3145: liberation_contexte_cas(s_etat_processus);
! 3146: liberation_queue_signaux(s_etat_processus);
! 3147:
! 3148: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3149: stackoverflow_deinstall_handler();
! 3150: # endif
! 3151:
! 3152: # ifdef HAVE_SIGSEGV_RECOVERY
! 3153: if (debug == d_faux)
! 3154: {
! 3155: sigsegv_deinstall_handler();
! 3156: }
! 3157: # endif
! 3158:
1.1 bertrand 3159: if ((*s_etat_processus).langue == 'F')
3160: {
3161: printf("+++Système : Erreur d'écriture dans un fichier\n");
3162: }
3163: else
3164: {
3165: printf("+++System : Cannot write in file\n");
3166: }
3167:
3168: return(EXIT_FAILURE);
3169: }
3170:
3171: if (fprintf(f_source,
3172: "<< DO HALT UNTIL FALSE END >>\n") < 0)
3173: {
1.124 ! bertrand 3174: # ifndef SEMAPHORES_NOMMES
! 3175: sem_post(&((*s_etat_processus).semaphore_fork));
! 3176: sem_post(&semaphore_gestionnaires_signaux);
! 3177: sem_destroy(&semaphore_gestionnaires_signaux);
! 3178: sem_destroy(&((*s_etat_processus)
! 3179: .semaphore_fork));
! 3180: # else
! 3181: sem_post((*s_etat_processus).semaphore_fork);
! 3182: sem_post(semaphore_gestionnaires_signaux);
! 3183: sem_destroy2(semaphore_gestionnaires_signaux,
! 3184: getpid(), SEM_SIGNAUX);
! 3185: sem_destroy3((*s_etat_processus).semphore_fork,
! 3186: getpid(), pthread_self(), SEM_FORK);
! 3187: # endif
! 3188:
! 3189: liberation_contexte_cas(s_etat_processus);
! 3190: liberation_queue_signaux(s_etat_processus);
! 3191:
! 3192: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3193: stackoverflow_deinstall_handler();
! 3194: # endif
! 3195:
! 3196: # ifdef HAVE_SIGSEGV_RECOVERY
! 3197: if (debug == d_faux)
! 3198: {
! 3199: sigsegv_deinstall_handler();
! 3200: }
! 3201: # endif
! 3202:
1.1 bertrand 3203: if ((*s_etat_processus).langue == 'F')
3204: {
3205: printf("+++Système : Erreur d'écriture dans un fichier\n");
3206: }
3207: else
3208: {
3209: printf("+++System : Cannot write in file\n");
3210: }
3211:
3212: return(EXIT_FAILURE);
3213: }
3214:
3215: if (fclose(f_source) != 0)
3216: {
1.124 ! bertrand 3217: # ifndef SEMAPHORES_NOMMES
! 3218: sem_post(&((*s_etat_processus).semaphore_fork));
! 3219: sem_post(&semaphore_gestionnaires_signaux);
! 3220: sem_destroy(&semaphore_gestionnaires_signaux);
! 3221: sem_destroy(&((*s_etat_processus)
! 3222: .semaphore_fork));
! 3223: # else
! 3224: sem_post((*s_etat_processus).semaphore_fork);
! 3225: sem_post(semaphore_gestionnaires_signaux);
! 3226: sem_destroy2(semaphore_gestionnaires_signaux,
! 3227: getpid(), SEM_SIGNAUX);
! 3228: sem_destroy3((*s_etat_processus).semphore_fork,
! 3229: getpid(), pthread_self(), SEM_FORK);
! 3230: # endif
! 3231:
! 3232: liberation_contexte_cas(s_etat_processus);
! 3233: liberation_queue_signaux(s_etat_processus);
! 3234:
! 3235: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3236: stackoverflow_deinstall_handler();
! 3237: # endif
! 3238:
! 3239: # ifdef HAVE_SIGSEGV_RECOVERY
! 3240: if (debug == d_faux)
! 3241: {
! 3242: sigsegv_deinstall_handler();
! 3243: }
! 3244: # endif
! 3245:
1.1 bertrand 3246: if ((*s_etat_processus).langue == 'F')
3247: {
3248: printf("+++Système : Fichier indisponible\n");
3249: }
3250: else
3251: {
3252: printf("+++System : File unavailable\n");
3253: }
3254:
3255: return(EXIT_FAILURE);
3256: }
3257:
3258: (*s_etat_processus).lancement_interactif = d_vrai;
3259: (*s_etat_processus).nom_fichier_source =
3260: nom_fichier_temporaire;
3261:
3262: presence_definition = 'O';
3263: }
3264: else
3265: {
3266: nom_fichier_temporaire = NULL;
3267: }
3268:
3269: if ((*s_etat_processus).nom_fichier_source == NULL)
3270: {
3271: erreur_fichier = d_erreur;
3272: }
3273: else
3274: {
3275: erreur_fichier = caracteristiques_fichier(s_etat_processus,
3276: (*s_etat_processus).nom_fichier_source,
3277: &existence, &ouverture, &unite_fichier);
3278: }
3279:
3280: if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) &&
3281: (option_S == d_faux))
3282: {
1.124 ! bertrand 3283: # ifndef SEMAPHORES_NOMMES
! 3284: sem_post(&((*s_etat_processus).semaphore_fork));
! 3285: sem_post(&semaphore_gestionnaires_signaux);
! 3286: sem_destroy(&semaphore_gestionnaires_signaux);
! 3287: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3288: # else
! 3289: sem_post((*s_etat_processus).semaphore_fork);
! 3290: sem_post(semaphore_gestionnaires_signaux);
! 3291: sem_destroy2(semaphore_gestionnaires_signaux,
! 3292: getpid(), SEM_SIGNAUX);
! 3293: sem_destroy3((*s_etat_processus).semphore_fork,
! 3294: getpid(), pthread_self(), SEM_FORK);
! 3295: # endif
! 3296:
! 3297: liberation_contexte_cas(s_etat_processus);
! 3298: liberation_queue_signaux(s_etat_processus);
! 3299:
! 3300: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3301: stackoverflow_deinstall_handler();
! 3302: # endif
! 3303:
! 3304: # ifdef HAVE_SIGSEGV_RECOVERY
! 3305: if (debug == d_faux)
! 3306: {
! 3307: sigsegv_deinstall_handler();
! 3308: }
! 3309: # endif
! 3310:
1.1 bertrand 3311: if (presence_definition == 'O')
3312: {
3313: if ((*s_etat_processus).langue == 'F')
3314: {
3315: printf("+++Erreur : Fichier %s inexistant\n",
3316: (*s_etat_processus).nom_fichier_source);
3317: }
3318: else
3319: {
3320: printf("+++Error : File %s not found\n",
3321: (*s_etat_processus).nom_fichier_source);
3322: }
3323:
1.13 bertrand 3324: erreur = d_erreur;
1.1 bertrand 3325: }
3326: else
3327: {
3328: if ((*s_etat_processus).langue == 'F')
3329: {
3330: printf("+++Erreur : Absence de définition à exécuter\n");
3331: }
3332: else
3333: {
3334: printf("+++Error : Any executable definition\n");
3335: }
3336: }
1.3 bertrand 3337:
3338: return(EXIT_FAILURE);
1.1 bertrand 3339: }
3340:
3341: if ((*s_etat_processus).chemin_fichiers_temporaires == NULL)
3342: {
1.124 ! bertrand 3343: # ifndef SEMAPHORES_NOMMES
! 3344: sem_post(&((*s_etat_processus).semaphore_fork));
! 3345: sem_post(&semaphore_gestionnaires_signaux);
! 3346: sem_destroy(&semaphore_gestionnaires_signaux);
! 3347: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3348: # else
! 3349: sem_post((*s_etat_processus).semaphore_fork);
! 3350: sem_post(semaphore_gestionnaires_signaux);
! 3351: sem_destroy2(semaphore_gestionnaires_signaux,
! 3352: getpid(), SEM_SIGNAUX);
! 3353: sem_destroy3((*s_etat_processus).semphore_fork,
! 3354: getpid(), pthread_self(), SEM_FORK);
! 3355: # endif
! 3356:
! 3357: liberation_contexte_cas(s_etat_processus);
! 3358: liberation_queue_signaux(s_etat_processus);
! 3359:
! 3360: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3361: stackoverflow_deinstall_handler();
! 3362: # endif
! 3363:
! 3364: # ifdef HAVE_SIGSEGV_RECOVERY
! 3365: if (debug == d_faux)
! 3366: {
! 3367: sigsegv_deinstall_handler();
! 3368: }
! 3369: # endif
! 3370:
1.1 bertrand 3371: if ((*s_etat_processus).langue == 'F')
3372: {
3373: printf("+++Système : Chemin des fichiers temporaires nul\n");
3374: }
3375: else
3376: {
3377: printf("+++System : Null temporary files path\n");
3378: }
3379:
3380: return(EXIT_FAILURE);
3381: }
3382:
3383: if ((*s_etat_processus).debug == d_vrai)
3384: {
3385: if ((*s_etat_processus).langue == 'F')
3386: {
3387: printf("[%d] Chemin des fichiers temporaires %s\n\n",
3388: (int) getpid(),
3389: (*s_etat_processus).chemin_fichiers_temporaires);
3390: }
3391: else
3392: {
3393: printf("[%d] Temporary files path %s\n\n",
3394: (int) getpid(),
3395: (*s_etat_processus).chemin_fichiers_temporaires);
3396: }
3397: }
3398:
1.13 bertrand 3399: if ((erreur == d_absence_erreur) && (presence_definition == 'O'))
1.1 bertrand 3400: {
3401: (*s_etat_processus).profilage = (option_P != 0) ? d_vrai : d_faux;
3402: (*s_etat_processus).niveau_profilage = option_P;
3403: (*s_etat_processus).pile_profilage = NULL;
3404: (*s_etat_processus).pile_profilage_fonctions = NULL;
3405: gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);
3406:
3407: (*s_etat_processus).liste_mutexes = NULL;
1.117 bertrand 3408: (*s_etat_processus).sections_critiques = 0;
1.1 bertrand 3409:
3410: (*s_etat_processus).test_instruction = 'N';
3411: (*s_etat_processus).nombre_arguments = 0;
3412: (*s_etat_processus).affichage_arguments = 'N';
1.6 bertrand 3413: (*s_etat_processus).autorisation_conversion_chaine = 'Y';
1.1 bertrand 3414: (*s_etat_processus).autorisation_evaluation_nom = 'Y';
1.62 bertrand 3415:
3416: if (mode_interactif == d_vrai)
3417: {
3418: (*s_etat_processus).autorisation_nom_implicite = 'Y';
3419: }
3420: else
3421: {
3422: (*s_etat_processus).autorisation_nom_implicite = 'N';
3423: }
3424:
1.1 bertrand 3425: (*s_etat_processus).autorisation_empilement_programme = 'N';
3426: (*s_etat_processus).requete_arret = 'N';
1.4 bertrand 3427: (*s_etat_processus).evaluation_forcee = 'N';
1.51 bertrand 3428: (*s_etat_processus).recherche_type = 'N';
1.1 bertrand 3429:
3430: (*s_etat_processus).constante_symbolique = 'N';
3431: (*s_etat_processus).traitement_symbolique = 'N';
3432:
3433: (*s_etat_processus).expression_courante = NULL;
3434: (*s_etat_processus).objet_courant = NULL;
3435: (*s_etat_processus).evaluation_expression_compilee = 'N';
3436:
3437: (*s_etat_processus).l_base_pile = NULL;
3438: (*s_etat_processus).l_base_pile_last = NULL;
3439:
1.64 bertrand 3440: (*s_etat_processus).s_arbre_variables = NULL;
1.65 bertrand 3441: (*s_etat_processus).l_liste_variables_par_niveau = NULL;
1.1 bertrand 3442: (*s_etat_processus).gel_liste_variables = d_faux;
1.64 bertrand 3443: (*s_etat_processus).pointeur_variable_courante = NULL;
1.119 bertrand 3444: (*s_etat_processus).pointeur_variable_statique_courante = NULL;
3445: (*s_etat_processus).l_liste_variables_statiques = NULL;
1.1 bertrand 3446: (*s_etat_processus).niveau_courant = 0;
3447: (*s_etat_processus).niveau_initial = 0;
3448: (*s_etat_processus).creation_variables_statiques = d_faux;
3449: (*s_etat_processus).creation_variables_partagees = d_faux;
3450:
3451: (*s_etat_processus).s_bibliotheques = NULL;
3452: (*s_etat_processus).s_instructions_externes = NULL;
3453: (*s_etat_processus).nombre_instructions_externes = 0;
3454:
3455: (*s_etat_processus).systeme_axes = 0;
3456:
3457: (*s_etat_processus).x_min = -10.;
3458: (*s_etat_processus).x_max = 10.;
3459: (*s_etat_processus).y_min = -10.;
3460: (*s_etat_processus).y_max = 10.;
3461: (*s_etat_processus).z_min = -10.;
3462: (*s_etat_processus).z_max = 10.;
3463:
3464: (*s_etat_processus).x2_min = -10.;
3465: (*s_etat_processus).x2_max = 10.;
3466: (*s_etat_processus).y2_min = -10.;
3467: (*s_etat_processus).y2_max = 10.;
3468: (*s_etat_processus).z2_min = -10.;
3469: (*s_etat_processus).z2_max = 10.;
3470:
3471: (*s_etat_processus).resolution = .01;
3472:
3473: (*s_etat_processus).souris_active = d_faux;
3474:
3475: (*s_etat_processus).echelle_automatique_x = d_faux;
3476: (*s_etat_processus).echelle_automatique_y = d_faux;
3477: (*s_etat_processus).echelle_automatique_z = d_faux;
3478:
3479: (*s_etat_processus).echelle_automatique_x2 = d_faux;
3480: (*s_etat_processus).echelle_automatique_y2 = d_faux;
3481: (*s_etat_processus).echelle_automatique_z2 = d_faux;
3482:
3483: (*s_etat_processus).echelle_log_x = d_faux;
3484: (*s_etat_processus).echelle_log_y = d_faux;
3485: (*s_etat_processus).echelle_log_z = d_faux;
3486:
3487: (*s_etat_processus).echelle_log_x2 = d_faux;
3488: (*s_etat_processus).echelle_log_y2 = d_faux;
3489: (*s_etat_processus).echelle_log_z2 = d_faux;
3490:
3491: (*s_etat_processus).point_de_vue_theta = 4 * atan((real8) 1) / 6;
3492: (*s_etat_processus).point_de_vue_phi = 4 * atan((real8) 1) / 3;
3493: (*s_etat_processus).echelle_3D = 1;
3494:
3495: strcpy((*s_etat_processus).type_trace_eq, "FONCTION");
3496: strcpy((*s_etat_processus).type_trace_sigma, "POINTS");
3497: (*s_etat_processus).fichiers_graphiques = NULL;
3498: (*s_etat_processus).nom_fichier_impression = NULL;
3499: strcpy((*s_etat_processus).format_papier, "a4paper");
3500: (*s_etat_processus).entree_standard = NULL;
3501: (*s_etat_processus).s_marques = NULL;
3502: (*s_etat_processus).requete_nouveau_plan = d_vrai;
3503: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
3504:
3505: (*s_etat_processus).l_base_pile = NULL;
3506: (*s_etat_processus).hauteur_pile_operationnelle = 0;
3507: (*s_etat_processus).l_base_pile_contextes = NULL;
3508: (*s_etat_processus).l_base_pile_taille_contextes = NULL;
3509:
3510: (*s_etat_processus).position_courante = 0;
3511:
3512: (*s_etat_processus).l_base_pile_systeme = NULL;
3513: (*s_etat_processus).hauteur_pile_systeme = 0;
3514:
3515: (*s_etat_processus).l_base_pile_processus = NULL;
3516: (*s_etat_processus).presence_pipes = d_faux;
3517: (*s_etat_processus).pipe_donnees = 0;
3518: (*s_etat_processus).pipe_acquittement = 0;
3519: (*s_etat_processus).pipe_injections = 0;
3520: (*s_etat_processus).pipe_nombre_injections = 0;
3521: (*s_etat_processus).nombre_objets_injectes = 0;
3522: (*s_etat_processus).nombre_objets_envoyes_non_lus = 0;
3523: (*s_etat_processus).pourcentage_maximal_cpu = 100;
3524: (*s_etat_processus).temps_maximal_cpu = 0;
3525: (*s_etat_processus).thread_fusible = 0;
3526: (*s_etat_processus).presence_fusible = d_faux;
3527:
3528: (*s_etat_processus).niveau_recursivite = 0;
3529: (*s_etat_processus).generateur_aleatoire = NULL;
3530: (*s_etat_processus).type_generateur_aleatoire = NULL;
3531:
3532: (*s_etat_processus).colonne_statistique_1 = 1;
3533: (*s_etat_processus).colonne_statistique_2 = 2;
3534:
3535: (*s_etat_processus).debug_programme = d_faux;
3536: (*s_etat_processus).execution_pas_suivant = d_faux;
3537: (*s_etat_processus).traitement_instruction_halt = d_faux;
3538:
3539: (*s_etat_processus).derniere_exception = d_ep;
3540: (*s_etat_processus).derniere_erreur_systeme = d_es;
3541: (*s_etat_processus).derniere_erreur_execution = d_ex;
3542: (*s_etat_processus).derniere_erreur_evaluation = d_ex;
3543: (*s_etat_processus).derniere_erreur_fonction_externe = 0;
3544:
3545: (*s_etat_processus).erreur_processus_fils = d_faux;
3546: (*s_etat_processus).erreur_systeme_processus_fils = d_es;
3547: (*s_etat_processus).erreur_execution_processus_fils = d_ex;
3548: (*s_etat_processus).pid_erreur_processus_fils = 0;
3549: (*s_etat_processus).exception_processus_fils = d_ep;
3550: (*s_etat_processus).core = core;
3551: (*s_etat_processus).invalidation_message_erreur = d_faux;
3552: (*s_etat_processus).s_objet_errone = NULL;
3553: (*s_etat_processus).s_objet_erreur = NULL;
3554:
3555: (*s_etat_processus).retour_routine_evaluation = 'N';
3556:
3557: (*s_etat_processus).traitement_interruption = 'N';
3558: (*s_etat_processus).traitement_interruptible = 'Y';
3559: (*s_etat_processus).nombre_interruptions_en_queue = 0;
3560: (*s_etat_processus).nombre_interruptions_non_affectees = 0;
3561:
3562: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
3563: {
3564: (*s_etat_processus).masque_interruptions[i] = 'N';
3565: (*s_etat_processus).queue_interruptions[i] = 0;
3566: (*s_etat_processus).corps_interruptions[i] = NULL;
3567: (*s_etat_processus).pile_origine_interruptions[i] = NULL;
3568: }
3569:
1.20 bertrand 3570: (*s_etat_processus).at_exit = NULL;
1.34 bertrand 3571: (*s_etat_processus).at_poke = NULL;
3572: (*s_etat_processus).traitement_at_poke = 'N';
1.19 bertrand 3573:
1.1 bertrand 3574: (*s_etat_processus).pointeurs_caracteres = NULL;
3575: (*s_etat_processus).arbre_instructions = NULL;
3576:
3577: (*s_etat_processus).tid_processus_pere = pthread_self();
1.113 bertrand 3578: (*s_etat_processus).tid = pthread_self();
1.1 bertrand 3579: (*s_etat_processus).pid_processus_pere = getpid();
3580: (*s_etat_processus).processus_detache = d_vrai;
3581: (*s_etat_processus).var_volatile_processus_pere = -1;
1.45 bertrand 3582: (*s_etat_processus).var_volatile_processus_racine = -1;
1.1 bertrand 3583: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
3584: (*s_etat_processus).var_volatile_alarme = 0;
3585: (*s_etat_processus).var_volatile_requete_arret = 0;
3586: (*s_etat_processus).var_volatile_requete_arret2 = 0;
3587: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
3588: (*s_etat_processus).var_volatile_traitement_sigint = 0;
3589: (*s_etat_processus).var_volatile_recursivite = 0;
3590: (*s_etat_processus).var_volatile_exception_gsl = 0;
1.22 bertrand 3591: (*s_etat_processus).arret_depuis_abort = 0;
1.83 bertrand 3592: (*s_etat_processus).pointeur_signal_lecture = 0;
3593: (*s_etat_processus).pointeur_signal_ecriture = 0;
1.1 bertrand 3594:
3595: initialisation_allocateur(s_etat_processus);
3596: initialisation_drapeaux(s_etat_processus);
1.65 bertrand 3597: initialisation_variables(s_etat_processus);
3598: initialisation_instructions(s_etat_processus);
1.1 bertrand 3599:
3600: if ((*s_etat_processus).erreur_systeme != d_es)
3601: {
1.124 ! bertrand 3602: # ifndef SEMAPHORES_NOMMES
! 3603: sem_post(&((*s_etat_processus).semaphore_fork));
! 3604: sem_post(&semaphore_gestionnaires_signaux);
! 3605: sem_destroy(&semaphore_gestionnaires_signaux);
! 3606: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3607: # else
! 3608: sem_post((*s_etat_processus).semaphore_fork);
! 3609: sem_post(semaphore_gestionnaires_signaux);
! 3610: sem_destroy2(semaphore_gestionnaires_signaux,
! 3611: getpid(), SEM_SIGNAUX);
! 3612: sem_destroy3((*s_etat_processus).semphore_fork,
! 3613: getpid(), pthread_self(), SEM_FORK);
! 3614: # endif
! 3615:
! 3616: liberation_contexte_cas(s_etat_processus);
! 3617: liberation_queue_signaux(s_etat_processus);
! 3618:
! 3619: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3620: stackoverflow_deinstall_handler();
! 3621: # endif
! 3622:
! 3623: # ifdef HAVE_SIGSEGV_RECOVERY
! 3624: if (debug == d_faux)
! 3625: {
! 3626: sigsegv_deinstall_handler();
! 3627: }
! 3628: # endif
! 3629:
1.1 bertrand 3630: if ((*s_etat_processus).langue == 'F')
3631: {
3632: printf("+++Système : Mémoire insuffisante\n");
3633: }
3634: else
3635: {
3636: printf("+++System : Not enough memory\n");
3637: }
3638:
3639: return(EXIT_FAILURE);
3640: }
3641:
3642: if (((*s_etat_processus).instruction_derniere_erreur =
1.32 bertrand 3643: malloc(sizeof(unsigned char))) == NULL)
1.1 bertrand 3644: {
1.124 ! bertrand 3645: # ifndef SEMAPHORES_NOMMES
! 3646: sem_post(&((*s_etat_processus).semaphore_fork));
! 3647: sem_post(&semaphore_gestionnaires_signaux);
! 3648: sem_destroy(&semaphore_gestionnaires_signaux);
! 3649: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3650: # else
! 3651: sem_post((*s_etat_processus).semaphore_fork);
! 3652: sem_post(semaphore_gestionnaires_signaux);
! 3653: sem_destroy2(semaphore_gestionnaires_signaux,
! 3654: getpid(), SEM_SIGNAUX);
! 3655: sem_destroy3((*s_etat_processus).semphore_fork,
! 3656: getpid(), pthread_self(), SEM_FORK);
! 3657: # endif
! 3658:
! 3659: liberation_contexte_cas(s_etat_processus);
! 3660: liberation_queue_signaux(s_etat_processus);
! 3661:
! 3662: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3663: stackoverflow_deinstall_handler();
! 3664: # endif
! 3665:
! 3666: # ifdef HAVE_SIGSEGV_RECOVERY
! 3667: if (debug == d_faux)
! 3668: {
! 3669: sigsegv_deinstall_handler();
! 3670: }
! 3671: # endif
! 3672:
1.1 bertrand 3673: erreur = d_es_allocation_memoire;
3674:
3675: if ((*s_etat_processus).langue == 'F')
3676: {
3677: printf("+++Système : Mémoire insuffisante\n");
3678: }
3679: else
3680: {
3681: printf("+++System : Not enough memory\n");
3682: }
3683:
3684: return(EXIT_FAILURE);
3685: }
3686:
3687: strcpy((*s_etat_processus).instruction_derniere_erreur, "");
3688: (*s_etat_processus).niveau_derniere_erreur = 0;
3689:
3690: if (traitement_fichier_temporaire == 'Y')
3691: {
3692: (*s_etat_processus).mode_interactif = 'Y';
3693: }
3694: else
3695: {
3696: (*s_etat_processus).mode_interactif = 'N';
3697: }
3698:
3699: if (((*s_etat_processus).instruction_courante = (unsigned char *)
3700: malloc(sizeof(unsigned char))) == NULL)
3701: {
1.124 ! bertrand 3702: # ifndef SEMAPHORES_NOMMES
! 3703: sem_post(&((*s_etat_processus).semaphore_fork));
! 3704: sem_post(&semaphore_gestionnaires_signaux);
! 3705: sem_destroy(&semaphore_gestionnaires_signaux);
! 3706: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3707: # else
! 3708: sem_post((*s_etat_processus).semaphore_fork);
! 3709: sem_post(semaphore_gestionnaires_signaux);
! 3710: sem_destroy2(semaphore_gestionnaires_signaux,
! 3711: getpid(), SEM_SIGNAUX);
! 3712: sem_destroy3((*s_etat_processus).semphore_fork,
! 3713: getpid(), pthread_self(), SEM_FORK);
! 3714: # endif
! 3715:
! 3716: liberation_contexte_cas(s_etat_processus);
! 3717: liberation_queue_signaux(s_etat_processus);
! 3718:
! 3719: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3720: stackoverflow_deinstall_handler();
! 3721: # endif
! 3722:
! 3723: # ifdef HAVE_SIGSEGV_RECOVERY
! 3724: if (debug == d_faux)
! 3725: {
! 3726: sigsegv_deinstall_handler();
! 3727: }
! 3728: # endif
! 3729:
1.1 bertrand 3730: erreur = d_es_allocation_memoire;
3731:
3732: if ((*s_etat_processus).langue == 'F')
3733: {
3734: printf("+++Système : Mémoire insuffisante\n");
3735: }
3736: else
3737: {
3738: printf("+++System : Not enough memory\n");
3739: }
3740:
3741: return(EXIT_FAILURE);
3742: }
3743:
3744: (*s_etat_processus).instruction_courante[0] = d_code_fin_chaine;
3745:
3746: empilement_pile_systeme(s_etat_processus);
3747:
3748: free((*s_etat_processus).instruction_courante);
3749:
1.41 bertrand 3750: if ((*s_etat_processus).erreur_systeme != d_es)
1.1 bertrand 3751: {
3752: erreur = d_es_allocation_memoire;
3753: }
3754: else
3755: {
3756: (*((*s_etat_processus).l_base_pile_systeme))
3757: .retour_definition = 'Y';
3758:
1.111 bertrand 3759: (*s_etat_processus).indep = allocation(s_etat_processus, NON);
3760: (*s_etat_processus).depend = allocation(s_etat_processus, NON);
1.1 bertrand 3761: (*s_etat_processus).parametres_courbes_de_niveau =
1.111 bertrand 3762: allocation(s_etat_processus, NON);
1.1 bertrand 3763:
3764: if (((*s_etat_processus).indep != NULL) &&
3765: ((*s_etat_processus).depend != NULL) &&
3766: ((*s_etat_processus).parametres_courbes_de_niveau
3767: != NULL))
3768: {
3769: (*((*s_etat_processus).indep)).type = NOM;
3770: (*((*s_etat_processus).depend)).type = NOM;
3771: (*((*s_etat_processus).
3772: parametres_courbes_de_niveau)).type = LST;
3773:
3774: initialisation_objet((*s_etat_processus).indep);
3775: initialisation_objet((*s_etat_processus).depend);
3776: initialisation_objet((*s_etat_processus)
3777: .parametres_courbes_de_niveau);
3778:
3779: (*((*s_etat_processus).indep)).objet = (struct_nom *)
3780: malloc(sizeof(struct_nom));
3781: (*((*s_etat_processus).depend)).objet = (struct_nom *)
3782: malloc(sizeof(struct_nom));
3783: (*((*s_etat_processus).parametres_courbes_de_niveau))
3784: .objet = (struct_liste_chainee *)
3785: malloc(sizeof(struct_liste_chainee));
3786:
3787: if (((*((*s_etat_processus).depend)).objet == NULL) ||
3788: ((*((*s_etat_processus).depend)).objet == NULL) ||
3789: ((*((*s_etat_processus).
3790: parametres_courbes_de_niveau)).objet == NULL))
3791: {
1.124 ! bertrand 3792: # ifndef SEMAPHORES_NOMMES
! 3793: sem_post(&((*s_etat_processus).semaphore_fork));
! 3794: sem_post(&semaphore_gestionnaires_signaux);
! 3795: sem_destroy(&semaphore_gestionnaires_signaux);
! 3796: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3797: # else
! 3798: sem_post((*s_etat_processus).semaphore_fork);
! 3799: sem_post(semaphore_gestionnaires_signaux);
! 3800: sem_destroy2(semaphore_gestionnaires_signaux,
! 3801: getpid(), SEM_SIGNAUX);
! 3802: sem_destroy3((*s_etat_processus).semphore_fork,
! 3803: getpid(), pthread_self(), SEM_FORK);
! 3804: # endif
! 3805:
! 3806: liberation_contexte_cas(s_etat_processus);
! 3807: liberation_queue_signaux(s_etat_processus);
! 3808:
! 3809: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3810: stackoverflow_deinstall_handler();
! 3811: # endif
! 3812:
! 3813: # ifdef HAVE_SIGSEGV_RECOVERY
! 3814: if (debug == d_faux)
! 3815: {
! 3816: sigsegv_deinstall_handler();
! 3817: }
! 3818: # endif
! 3819:
1.1 bertrand 3820: erreur = d_es_allocation_memoire;
3821:
3822: if ((*s_etat_processus).langue == 'F')
3823: {
3824: printf("+++Système : Mémoire insuffisante\n");
3825: }
3826: else
3827: {
3828: printf("+++System : Not enough memory\n");
3829: }
3830:
3831: return(EXIT_FAILURE);
3832: }
3833:
3834: (*((struct_nom *) (*((*s_etat_processus).indep)).objet))
3835: .nom = malloc(2 * sizeof(unsigned char));
3836: (*((struct_nom *) (*((*s_etat_processus).depend)).objet))
3837: .nom = malloc(2 * sizeof(unsigned char));
3838:
3839: if (((*((struct_nom *) (*((*s_etat_processus).indep))
3840: .objet)).nom == NULL) || ((*((struct_nom *)
3841: (*((*s_etat_processus).depend)).objet)).nom ==
3842: NULL))
3843: {
1.124 ! bertrand 3844: # ifndef SEMAPHORES_NOMMES
! 3845: sem_post(&((*s_etat_processus).semaphore_fork));
! 3846: sem_post(&semaphore_gestionnaires_signaux);
! 3847: sem_destroy(&semaphore_gestionnaires_signaux);
! 3848: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3849: # else
! 3850: sem_post((*s_etat_processus).semaphore_fork);
! 3851: sem_post(semaphore_gestionnaires_signaux);
! 3852: sem_destroy2(semaphore_gestionnaires_signaux,
! 3853: getpid(), SEM_SIGNAUX);
! 3854: sem_destroy3((*s_etat_processus).semphore_fork,
! 3855: getpid(), pthread_self(), SEM_FORK);
! 3856: # endif
! 3857:
! 3858: liberation_contexte_cas(s_etat_processus);
! 3859: liberation_queue_signaux(s_etat_processus);
! 3860:
! 3861: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3862: stackoverflow_deinstall_handler();
! 3863: # endif
! 3864:
! 3865: # ifdef HAVE_SIGSEGV_RECOVERY
! 3866: if (debug == d_faux)
! 3867: {
! 3868: sigsegv_deinstall_handler();
! 3869: }
! 3870: # endif
! 3871:
1.1 bertrand 3872: erreur = d_es_allocation_memoire;
3873:
3874: if ((*s_etat_processus).langue == 'F')
3875: {
3876: printf("+++Système : Mémoire insuffisante\n");
3877: }
3878: else
3879: {
3880: printf("+++System : Not enough memory\n");
3881: }
3882:
3883: return(EXIT_FAILURE);
3884: }
3885:
3886: strcpy((*((struct_nom *) (*((*s_etat_processus).indep))
3887: .objet)).nom, "X");
3888: strcpy((*((struct_nom *) (*((*s_etat_processus).depend))
3889: .objet)).nom, "Y");
3890:
3891: (*((struct_nom *) (*((*s_etat_processus).indep))
3892: .objet)).symbole = d_vrai;
3893: (*((struct_nom *) (*((*s_etat_processus).depend))
3894: .objet)).symbole = d_vrai;
3895:
3896: (*((struct_liste_chainee *) (*((*s_etat_processus)
3897: .parametres_courbes_de_niveau)).objet)).suivant
3898: = NULL;
3899:
3900: (*((struct_liste_chainee *) (*((*s_etat_processus)
3901: .parametres_courbes_de_niveau)).objet)).donnee
3902: = malloc(sizeof(struct_objet));
3903:
3904: (*s_etat_processus).legende =
3905: malloc(sizeof(unsigned char));
3906: (*s_etat_processus).label_x =
3907: malloc(sizeof(unsigned char));
3908: (*s_etat_processus).label_y =
3909: malloc(sizeof(unsigned char));
3910: (*s_etat_processus).label_z =
3911: malloc(sizeof(unsigned char));
3912: (*s_etat_processus).titre =
3913: malloc(sizeof(unsigned char));
3914:
3915: if (((*s_etat_processus).label_x == NULL) ||
3916: ((*s_etat_processus).label_y == NULL) ||
3917: ((*s_etat_processus).label_z == NULL) ||
3918: ((*s_etat_processus).titre == NULL) ||
3919: ((*s_etat_processus).legende == NULL) ||
3920: ((*((struct_liste_chainee *) (*((*s_etat_processus)
3921: .parametres_courbes_de_niveau)).objet)).donnee
3922: == NULL))
3923: {
1.124 ! bertrand 3924: # ifndef SEMAPHORES_NOMMES
! 3925: sem_post(&((*s_etat_processus).semaphore_fork));
! 3926: sem_post(&semaphore_gestionnaires_signaux);
! 3927: sem_destroy(&semaphore_gestionnaires_signaux);
! 3928: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3929: # else
! 3930: sem_post((*s_etat_processus).semaphore_fork);
! 3931: sem_post(semaphore_gestionnaires_signaux);
! 3932: sem_destroy2(semaphore_gestionnaires_signaux,
! 3933: getpid(), SEM_SIGNAUX);
! 3934: sem_destroy3((*s_etat_processus).semphore_fork,
! 3935: getpid(), pthread_self(), SEM_FORK);
! 3936: # endif
! 3937:
! 3938: liberation_contexte_cas(s_etat_processus);
! 3939: liberation_queue_signaux(s_etat_processus);
! 3940:
! 3941: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3942: stackoverflow_deinstall_handler();
! 3943: # endif
! 3944:
! 3945: # ifdef HAVE_SIGSEGV_RECOVERY
! 3946: if (debug == d_faux)
! 3947: {
! 3948: sigsegv_deinstall_handler();
! 3949: }
! 3950: # endif
! 3951:
1.1 bertrand 3952: erreur = d_es_allocation_memoire;
3953:
3954: if ((*s_etat_processus).langue == 'F')
3955: {
3956: printf("+++Système : Mémoire insuffisante\n");
3957: }
3958: else
3959: {
3960: printf("+++System : Not enough memory\n");
3961: }
3962:
3963: return(EXIT_FAILURE);
3964: }
3965:
3966: (*(*((struct_liste_chainee *) (*((*s_etat_processus)
3967: .parametres_courbes_de_niveau)).objet)).donnee)
3968: .type = CHN;
3969:
3970: initialisation_objet((*((struct_liste_chainee *)
3971: (*((*s_etat_processus)
3972: .parametres_courbes_de_niveau))
3973: .objet)).donnee);
3974:
3975: if (((*(*((struct_liste_chainee *) (*((*s_etat_processus)
3976: .parametres_courbes_de_niveau)).objet)).donnee)
3977: .objet = malloc(10 * sizeof(unsigned char)))
3978: == NULL)
3979: {
1.124 ! bertrand 3980: # ifndef SEMAPHORES_NOMMES
! 3981: sem_post(&((*s_etat_processus).semaphore_fork));
! 3982: sem_post(&semaphore_gestionnaires_signaux);
! 3983: sem_destroy(&semaphore_gestionnaires_signaux);
! 3984: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 3985: # else
! 3986: sem_post((*s_etat_processus).semaphore_fork);
! 3987: sem_post(semaphore_gestionnaires_signaux);
! 3988: sem_destroy2(semaphore_gestionnaires_signaux,
! 3989: getpid(), SEM_SIGNAUX);
! 3990: sem_destroy3((*s_etat_processus).semphore_fork,
! 3991: getpid(), pthread_self(), SEM_FORK);
! 3992: # endif
! 3993:
! 3994: liberation_contexte_cas(s_etat_processus);
! 3995: liberation_queue_signaux(s_etat_processus);
! 3996:
! 3997: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 3998: stackoverflow_deinstall_handler();
! 3999: # endif
! 4000:
! 4001: # ifdef HAVE_SIGSEGV_RECOVERY
! 4002: if (debug == d_faux)
! 4003: {
! 4004: sigsegv_deinstall_handler();
! 4005: }
! 4006: # endif
! 4007:
1.1 bertrand 4008: erreur = d_es_allocation_memoire;
4009:
4010: if ((*s_etat_processus).langue == 'F')
4011: {
4012: printf("+++Système : Mémoire insuffisante\n");
4013: }
4014: else
4015: {
4016: printf("+++System : Not enough memory\n");
4017: }
4018:
4019: return(EXIT_FAILURE);
4020: }
4021:
4022: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
4023: (*((*s_etat_processus)
4024: .parametres_courbes_de_niveau))
4025: .objet)).donnee).objet, "AUTOMATIC");
4026:
4027: (*s_etat_processus).label_x[0] = d_code_fin_chaine;
4028: (*s_etat_processus).label_y[0] = d_code_fin_chaine;
4029: (*s_etat_processus).label_z[0] = d_code_fin_chaine;
4030: (*s_etat_processus).titre[0] = d_code_fin_chaine;
4031: (*s_etat_processus).legende[0] = d_code_fin_chaine;
4032:
4033: (*s_etat_processus).nom_fichier_gnuplot = NULL;
4034: (*s_etat_processus).type_fichier_gnuplot = NULL;
4035:
4036: (*s_etat_processus).x_tics = 0;
4037: (*s_etat_processus).y_tics = 0;
4038: (*s_etat_processus).z_tics = 0;
4039:
4040: (*s_etat_processus).x_lines = d_vrai;
4041: (*s_etat_processus).y_lines = d_vrai;
4042: (*s_etat_processus).z_lines = d_vrai;
4043:
4044: (*s_etat_processus).mx_tics = -1;
4045: (*s_etat_processus).my_tics = -1;
4046: (*s_etat_processus).mz_tics = -1;
4047:
4048: (*s_etat_processus).mx_lines = d_faux;
4049: (*s_etat_processus).my_lines = d_faux;
4050: (*s_etat_processus).mz_lines = d_faux;
4051:
4052: (*s_etat_processus).x2_tics = -1;
4053: (*s_etat_processus).y2_tics = -1;
4054: (*s_etat_processus).z2_tics = -1;
4055:
4056: (*s_etat_processus).x2_lines = d_faux;
4057: (*s_etat_processus).y2_lines = d_faux;
4058: (*s_etat_processus).z2_lines = d_faux;
4059:
4060: (*s_etat_processus).mx2_tics = -1;
4061: (*s_etat_processus).my2_tics = -1;
4062: (*s_etat_processus).mz2_tics = -1;
4063:
4064: (*s_etat_processus).mx2_lines = d_faux;
4065: (*s_etat_processus).my2_lines = d_faux;
4066: (*s_etat_processus).mz2_lines = d_faux;
4067:
4068: (*s_etat_processus).mode_evaluation_expression = 'N';
4069: (*s_etat_processus).mode_execution_programme = 'Y';
4070:
4071: if ((*s_etat_processus).definitions_chainees == NULL)
4072: {
4073: if ((erreur = chainage(s_etat_processus)) !=
4074: d_absence_erreur)
4075: {
1.124 ! bertrand 4076: # ifndef SEMAPHORES_NOMMES
! 4077: sem_post(&((*s_etat_processus).semaphore_fork));
! 4078: sem_post(&semaphore_gestionnaires_signaux);
! 4079: sem_destroy(&semaphore_gestionnaires_signaux);
! 4080: sem_destroy(&((*s_etat_processus)
! 4081: .semaphore_fork));
! 4082: # else
! 4083: sem_post((*s_etat_processus).semaphore_fork);
! 4084: sem_post(semaphore_gestionnaires_signaux);
! 4085: sem_destroy2(semaphore_gestionnaires_signaux,
! 4086: getpid(), SEM_SIGNAUX);
! 4087: sem_destroy3((*s_etat_processus).semphore_fork,
! 4088: getpid(), pthread_self(), SEM_FORK);
! 4089: # endif
! 4090:
! 4091: liberation_contexte_cas(s_etat_processus);
! 4092: liberation_queue_signaux(s_etat_processus);
! 4093:
! 4094: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4095: stackoverflow_deinstall_handler();
! 4096: # endif
! 4097:
! 4098: # ifdef HAVE_SIGSEGV_RECOVERY
! 4099: if (debug == d_faux)
! 4100: {
! 4101: sigsegv_deinstall_handler();
! 4102: }
! 4103: # endif
! 4104:
1.1 bertrand 4105: if ((*s_etat_processus).langue == 'F')
4106: {
4107: printf("+++Fatal :"
4108: " Chaînage des définitions"
4109: " impossible\n");
4110: }
4111: else
4112: {
4113: printf("+++Fatal : Error in "
4114: "compilation\n");
4115: }
4116:
4117: if (traitement_fichier_temporaire == 'Y')
4118: {
4119: if (destruction_fichier(
4120: nom_fichier_temporaire)
4121: == d_erreur)
4122: {
4123: return(EXIT_FAILURE);
4124: }
4125:
4126: free(nom_fichier_temporaire);
4127: }
4128:
4129: return(EXIT_FAILURE);
4130: }
4131: }
4132:
4133: if ((erreur = compilation(s_etat_processus)) !=
4134: d_absence_erreur)
4135: {
1.124 ! bertrand 4136: # ifndef SEMAPHORES_NOMMES
! 4137: sem_post(&((*s_etat_processus).semaphore_fork));
! 4138: sem_post(&semaphore_gestionnaires_signaux);
! 4139: sem_destroy(&semaphore_gestionnaires_signaux);
! 4140: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4141: # else
! 4142: sem_post((*s_etat_processus).semaphore_fork);
! 4143: sem_post(semaphore_gestionnaires_signaux);
! 4144: sem_destroy2(semaphore_gestionnaires_signaux,
! 4145: getpid(), SEM_SIGNAUX);
! 4146: sem_destroy3((*s_etat_processus).semphore_fork,
! 4147: getpid(), pthread_self(), SEM_FORK);
! 4148: # endif
! 4149:
! 4150: liberation_contexte_cas(s_etat_processus);
! 4151: liberation_queue_signaux(s_etat_processus);
! 4152:
! 4153: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4154: stackoverflow_deinstall_handler();
! 4155: # endif
! 4156:
! 4157: # ifdef HAVE_SIGSEGV_RECOVERY
! 4158: if (debug == d_faux)
! 4159: {
! 4160: sigsegv_deinstall_handler();
! 4161: }
! 4162: # endif
! 4163:
1.1 bertrand 4164: if (traitement_fichier_temporaire == 'Y')
4165: {
4166: if (destruction_fichier(nom_fichier_temporaire)
4167: == d_erreur)
4168: {
4169: return(EXIT_FAILURE);
4170: }
4171:
4172: free(nom_fichier_temporaire);
4173: }
4174:
4175: printf("%s [%d]\n", message =
4176: messages(s_etat_processus), (int) getpid());
4177: free(message);
4178:
4179: if (test_cfsf(s_etat_processus, 51) == d_faux)
4180: {
4181: printf("%s", ds_beep);
4182: }
4183:
4184: if ((*s_etat_processus).core == d_vrai)
4185: {
4186: printf("\n");
4187:
4188: if ((*s_etat_processus).langue == 'F')
4189: {
4190: printf("+++Information : Génération du fichier "
4191: "rpl-core [%d]\n", (int) getpid());
4192: }
4193: else
4194: {
4195: printf("+++Information : Writing rpl-core "
4196: "file [%d]\n", (int) getpid());
4197: }
4198:
4199: rplcore(s_etat_processus);
4200:
4201: if ((*s_etat_processus).langue == 'F')
4202: {
4203: printf("+++Information : Processus tracé "
4204: "[%d]\n", (int) getpid());
4205: }
4206: else
4207: {
4208: printf("+++Information : Done [%d]\n",
4209: (int) getpid());
4210: }
4211:
4212: printf("\n");
4213: }
4214:
4215: return(EXIT_FAILURE);
4216: }
4217:
4218: (*s_etat_processus).position_courante = 0;
4219: (*s_etat_processus).traitement_cycle_exit = 'N';
4220:
1.64 bertrand 4221: if ((*s_etat_processus).s_arbre_variables == NULL)
1.1 bertrand 4222: {
1.124 ! bertrand 4223: # ifndef SEMAPHORES_NOMMES
! 4224: sem_post(&((*s_etat_processus).semaphore_fork));
! 4225: sem_post(&semaphore_gestionnaires_signaux);
! 4226: sem_destroy(&semaphore_gestionnaires_signaux);
! 4227: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4228: # else
! 4229: sem_post((*s_etat_processus).semaphore_fork);
! 4230: sem_post(semaphore_gestionnaires_signaux);
! 4231: sem_destroy2(semaphore_gestionnaires_signaux,
! 4232: getpid(), SEM_SIGNAUX);
! 4233: sem_destroy3((*s_etat_processus).semphore_fork,
! 4234: getpid(), pthread_self(), SEM_FORK);
! 4235: # endif
! 4236:
! 4237: liberation_contexte_cas(s_etat_processus);
! 4238: liberation_queue_signaux(s_etat_processus);
! 4239:
! 4240: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4241: stackoverflow_deinstall_handler();
! 4242: # endif
! 4243:
! 4244: # ifdef HAVE_SIGSEGV_RECOVERY
! 4245: if (debug == d_faux)
! 4246: {
! 4247: sigsegv_deinstall_handler();
! 4248: }
! 4249: # endif
! 4250:
1.1 bertrand 4251: if ((*s_etat_processus).langue == 'F')
4252: {
4253: printf("+++Fatal : Aucun point d'entrée\n");
4254: }
4255: else
4256: {
4257: printf("+++Fatal : Any entry point\n");
4258: }
4259:
4260: if (test_cfsf(s_etat_processus, 51) == d_faux)
4261: {
4262: printf("%s", ds_beep);
4263: }
4264:
4265: return(EXIT_FAILURE);
4266: }
4267:
4268: if (recherche_instruction_suivante(s_etat_processus)
4269: == d_erreur)
4270: {
1.124 ! bertrand 4271: # ifndef SEMAPHORES_NOMMES
! 4272: sem_post(&((*s_etat_processus).semaphore_fork));
! 4273: sem_post(&semaphore_gestionnaires_signaux);
! 4274: sem_destroy(&semaphore_gestionnaires_signaux);
! 4275: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4276: # else
! 4277: sem_post((*s_etat_processus).semaphore_fork);
! 4278: sem_post(semaphore_gestionnaires_signaux);
! 4279: sem_destroy2(semaphore_gestionnaires_signaux,
! 4280: getpid(), SEM_SIGNAUX);
! 4281: sem_destroy3((*s_etat_processus).semphore_fork,
! 4282: getpid(), pthread_self(), SEM_FORK);
! 4283: # endif
! 4284:
! 4285: liberation_contexte_cas(s_etat_processus);
! 4286: liberation_queue_signaux(s_etat_processus);
! 4287:
! 4288: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4289: stackoverflow_deinstall_handler();
! 4290: # endif
! 4291:
! 4292: # ifdef HAVE_SIGSEGV_RECOVERY
! 4293: if (debug == d_faux)
! 4294: {
! 4295: sigsegv_deinstall_handler();
! 4296: }
! 4297: # endif
! 4298:
1.1 bertrand 4299: if ((*s_etat_processus).langue == 'F')
4300: {
4301: printf("+++Fatal : Aucun point d'entrée\n");
4302: }
4303: else
4304: {
4305: printf("+++Fatal : Any entry point\n");
4306: }
4307:
4308: if (test_cfsf(s_etat_processus, 51) == d_faux)
4309: {
4310: printf("%s", ds_beep);
4311: }
4312:
4313: return(EXIT_FAILURE);
4314: }
4315:
4316: if (recherche_variable(s_etat_processus,
4317: (*s_etat_processus)
4318: .instruction_courante) == d_faux)
4319: {
1.124 ! bertrand 4320: # ifndef SEMAPHORES_NOMMES
! 4321: sem_post(&((*s_etat_processus).semaphore_fork));
! 4322: sem_post(&semaphore_gestionnaires_signaux);
! 4323: sem_destroy(&semaphore_gestionnaires_signaux);
! 4324: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4325: # else
! 4326: sem_post((*s_etat_processus).semaphore_fork);
! 4327: sem_post(semaphore_gestionnaires_signaux);
! 4328: sem_destroy2(semaphore_gestionnaires_signaux,
! 4329: getpid(), SEM_SIGNAUX);
! 4330: sem_destroy3((*s_etat_processus).semphore_fork,
! 4331: getpid(), pthread_self(), SEM_FORK);
! 4332: # endif
! 4333:
! 4334: liberation_contexte_cas(s_etat_processus);
! 4335: liberation_queue_signaux(s_etat_processus);
! 4336:
! 4337: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4338: stackoverflow_deinstall_handler();
! 4339: # endif
! 4340:
! 4341: # ifdef HAVE_SIGSEGV_RECOVERY
! 4342: if (debug == d_faux)
! 4343: {
! 4344: sigsegv_deinstall_handler();
! 4345: }
! 4346: # endif
! 4347:
1.1 bertrand 4348: if ((*s_etat_processus).langue == 'F')
4349: {
4350: printf("+++Fatal : Aucun point d'entrée\n");
4351: }
4352: else
4353: {
4354: printf("+++Fatal : Any entry point\n");
4355: }
4356:
4357: if (test_cfsf(s_etat_processus, 51) == d_faux)
4358: {
4359: printf("%s", ds_beep);
4360: }
4361:
4362: return(EXIT_FAILURE);
4363: }
4364:
1.64 bertrand 4365: if ((*(*s_etat_processus).pointeur_variable_courante)
4366: .niveau != 0)
1.1 bertrand 4367: {
1.124 ! bertrand 4368: # ifndef SEMAPHORES_NOMMES
! 4369: sem_post(&((*s_etat_processus).semaphore_fork));
! 4370: sem_post(&semaphore_gestionnaires_signaux);
! 4371: sem_destroy(&semaphore_gestionnaires_signaux);
! 4372: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4373: # else
! 4374: sem_post((*s_etat_processus).semaphore_fork);
! 4375: sem_post(semaphore_gestionnaires_signaux);
! 4376: sem_destroy2(semaphore_gestionnaires_signaux,
! 4377: getpid(), SEM_SIGNAUX);
! 4378: sem_destroy3((*s_etat_processus).semphore_fork,
! 4379: getpid(), pthread_self(), SEM_FORK);
! 4380: # endif
! 4381:
! 4382: liberation_contexte_cas(s_etat_processus);
! 4383: liberation_queue_signaux(s_etat_processus);
! 4384:
! 4385: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4386: stackoverflow_deinstall_handler();
! 4387: # endif
! 4388:
! 4389: # ifdef HAVE_SIGSEGV_RECOVERY
! 4390: if (debug == d_faux)
! 4391: {
! 4392: sigsegv_deinstall_handler();
! 4393: }
! 4394: # endif
! 4395:
1.1 bertrand 4396: if ((*s_etat_processus).langue == 'F')
4397: {
4398: printf("+++Fatal : Aucun point d'entrée\n");
4399: }
4400: else
4401: {
4402: printf("+++Fatal : Any entry point\n");
4403: }
4404:
4405: if (test_cfsf(s_etat_processus, 51) == d_faux)
4406: {
4407: printf("%s", ds_beep);
4408: }
4409:
4410: return(EXIT_FAILURE);
4411: }
4412:
4413: free((*s_etat_processus).instruction_courante);
4414: (*s_etat_processus).position_courante = 0;
4415:
4416: if (((*s_etat_processus).nom_fichier_historique =
4417: malloc((strlen(home) +
4418: strlen(ds_fichier_historique) + 2) *
4419: sizeof(unsigned char))) == NULL)
4420: {
1.124 ! bertrand 4421: # ifndef SEMAPHORES_NOMMES
! 4422: sem_post(&((*s_etat_processus).semaphore_fork));
! 4423: sem_post(&semaphore_gestionnaires_signaux);
! 4424: sem_destroy(&semaphore_gestionnaires_signaux);
! 4425: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 4426: # else
! 4427: sem_post((*s_etat_processus).semaphore_fork);
! 4428: sem_post(semaphore_gestionnaires_signaux);
! 4429: sem_destroy2(semaphore_gestionnaires_signaux,
! 4430: getpid(), SEM_SIGNAUX);
! 4431: sem_destroy3((*s_etat_processus).semphore_fork,
! 4432: getpid(), pthread_self(), SEM_FORK);
! 4433: # endif
! 4434:
! 4435: liberation_contexte_cas(s_etat_processus);
! 4436: liberation_queue_signaux(s_etat_processus);
! 4437:
! 4438: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4439: stackoverflow_deinstall_handler();
! 4440: # endif
! 4441:
! 4442: # ifdef HAVE_SIGSEGV_RECOVERY
! 4443: if (debug == d_faux)
! 4444: {
! 4445: sigsegv_deinstall_handler();
! 4446: }
! 4447: # endif
! 4448:
1.1 bertrand 4449: erreur = d_es_allocation_memoire;
4450:
4451: if ((*s_etat_processus).langue == 'F')
4452: {
4453: printf("+++Système : Mémoire insuffisante\n");
4454: }
4455: else
4456: {
4457: printf("+++System : Not enough memory\n");
4458: }
4459:
4460: return(EXIT_FAILURE);
4461: }
4462:
4463: sprintf((*s_etat_processus).nom_fichier_historique, "%s/%s",
4464: home, ds_fichier_historique);
4465:
4466: using_history();
1.109 bertrand 4467:
4468: // Pour pouvoir utiliser le keymap avant le premier
4469: // appel à readline().
4470: rl_initialize();
4471:
1.1 bertrand 4472: erreur_historique = read_history(
4473: (*s_etat_processus).nom_fichier_historique);
4474:
4475: gsl_set_error_handler(&traitement_exceptions_gsl);
4476:
4477: if (drapeau_encart == 'Y')
4478: {
4479: (*s_etat_processus).erreur_systeme = d_es;
4480: encart(s_etat_processus,
4481: (unsigned long) (5 * 1000000));
4482:
4483: if ((*s_etat_processus).erreur_systeme != d_es)
4484: {
4485: if ((message = messages(s_etat_processus))
4486: == NULL)
4487: {
1.124 ! bertrand 4488: # ifndef SEMAPHORES_NOMMES
! 4489: sem_post(&((*s_etat_processus)
! 4490: .semaphore_fork));
! 4491: sem_post(&semaphore_gestionnaires_signaux);
! 4492: sem_destroy(
! 4493: &semaphore_gestionnaires_signaux);
! 4494: sem_destroy(&((*s_etat_processus)
! 4495: .semaphore_fork));
! 4496: # else
! 4497: sem_post((*s_etat_processus)
! 4498: .semaphore_fork);
! 4499: sem_post(semaphore_gestionnaires_signaux);
! 4500: sem_destroy2(
! 4501: semaphore_gestionnaires_signaux,
! 4502: getpid(), SEM_SIGNAUX);
! 4503: sem_destroy3((*s_etat_processus)
! 4504: .semphore_fork,
! 4505: getpid(), pthread_self(), SEM_FORK);
! 4506: # endif
! 4507:
! 4508: liberation_contexte_cas(s_etat_processus);
! 4509: liberation_queue_signaux(s_etat_processus);
! 4510:
! 4511: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4512: stackoverflow_deinstall_handler();
! 4513: # endif
! 4514:
! 4515: # ifdef HAVE_SIGSEGV_RECOVERY
! 4516: if (debug == d_faux)
! 4517: {
! 4518: sigsegv_deinstall_handler();
! 4519: }
! 4520: # endif
! 4521:
1.1 bertrand 4522: erreur = d_es_allocation_memoire;
4523:
4524: if ((*s_etat_processus).langue == 'F')
4525: {
4526: printf("+++Système : Mémoire "
4527: "insuffisante\n");
4528: }
4529: else
4530: {
4531: printf("+++System : Not enough "
4532: "memory\n");
4533: }
4534:
4535: return(EXIT_FAILURE);
4536: }
4537:
4538: printf("%s [%d]\n", message, (int) getpid());
4539: free(message);
4540:
4541: return(EXIT_FAILURE);
4542: }
4543: }
4544:
4545: fflush(stdout);
4546:
4547: if (arguments != NULL)
4548: {
4549: tampon = (*s_etat_processus).definitions_chainees;
4550: (*s_etat_processus).definitions_chainees =
4551: arguments;
4552:
4553: if (analyse_syntaxique(s_etat_processus) ==
4554: d_erreur)
4555: {
4556: if ((*s_etat_processus).erreur_systeme != d_es)
4557: {
1.124 ! bertrand 4558: # ifndef SEMAPHORES_NOMMES
! 4559: sem_post(&((*s_etat_processus)
! 4560: .semaphore_fork));
! 4561: sem_post(&semaphore_gestionnaires_signaux);
! 4562: sem_destroy(
! 4563: &semaphore_gestionnaires_signaux);
! 4564: sem_destroy(&((*s_etat_processus)
! 4565: .semaphore_fork));
! 4566: # else
! 4567: sem_post((*s_etat_processus)
! 4568: .semaphore_fork);
! 4569: sem_post(semaphore_gestionnaires_signaux);
! 4570: sem_destroy2(
! 4571: semaphore_gestionnaires_signaux,
! 4572: getpid(), SEM_SIGNAUX);
! 4573: sem_destroy3((*s_etat_processus)
! 4574: .semphore_fork,
! 4575: getpid(), pthread_self(), SEM_FORK);
! 4576: # endif
! 4577:
! 4578: liberation_contexte_cas(s_etat_processus);
! 4579: liberation_queue_signaux(s_etat_processus);
! 4580:
! 4581: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4582: stackoverflow_deinstall_handler();
! 4583: # endif
! 4584:
! 4585: # ifdef HAVE_SIGSEGV_RECOVERY
! 4586: if (debug == d_faux)
! 4587: {
! 4588: sigsegv_deinstall_handler();
! 4589: }
! 4590: # endif
! 4591:
1.1 bertrand 4592: erreur = d_es_allocation_memoire;
4593:
4594: if ((*s_etat_processus).langue == 'F')
4595: {
4596: printf("+++Système : Mémoire "
4597: "insuffisante\n");
4598: }
4599: else
4600: {
4601: printf("+++System : Not enough "
4602: "memory\n");
4603: }
4604:
4605: return(EXIT_FAILURE);
4606: }
4607: else
4608: {
1.124 ! bertrand 4609: # ifndef SEMAPHORES_NOMMES
! 4610: sem_post(&((*s_etat_processus)
! 4611: .semaphore_fork));
! 4612: sem_post(&semaphore_gestionnaires_signaux);
! 4613: sem_destroy(
! 4614: &semaphore_gestionnaires_signaux);
! 4615: sem_destroy(&((*s_etat_processus)
! 4616: .semaphore_fork));
! 4617: # else
! 4618: sem_post((*s_etat_processus)
! 4619: .semaphore_fork);
! 4620: sem_post(semaphore_gestionnaires_signaux);
! 4621: sem_destroy2(
! 4622: semaphore_gestionnaires_signaux,
! 4623: getpid(), SEM_SIGNAUX);
! 4624: sem_destroy3((*s_etat_processus)
! 4625: .semphore_fork,
! 4626: getpid(), pthread_self(), SEM_FORK);
! 4627: # endif
! 4628:
! 4629: liberation_contexte_cas(s_etat_processus);
! 4630: liberation_queue_signaux(s_etat_processus);
! 4631:
! 4632: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4633: stackoverflow_deinstall_handler();
! 4634: # endif
! 4635:
! 4636: # ifdef HAVE_SIGSEGV_RECOVERY
! 4637: if (debug == d_faux)
! 4638: {
! 4639: sigsegv_deinstall_handler();
! 4640: }
! 4641: # endif
! 4642:
1.1 bertrand 4643: if ((*s_etat_processus).langue == 'F')
4644: {
4645: printf("+++Erreur : Erreur de "
4646: "syntaxe\n");
4647: }
4648: else
4649: {
4650: printf("+++Error : Syntax error\n");
4651: }
4652:
4653: return(EXIT_FAILURE);
4654: }
4655: }
4656:
4657: (*s_etat_processus).instruction_courante
4658: = arguments;
4659: (*s_etat_processus).definitions_chainees = tampon;
4660: (*s_etat_processus).position_courante = 0;
4661:
4662: recherche_type(s_etat_processus);
4663:
4664: if ((*s_etat_processus).erreur_systeme != d_es)
4665: {
1.124 ! bertrand 4666: # ifndef SEMAPHORES_NOMMES
! 4667: sem_post(&((*s_etat_processus).semaphore_fork));
! 4668: sem_post(&semaphore_gestionnaires_signaux);
! 4669: sem_destroy(&semaphore_gestionnaires_signaux);
! 4670: sem_destroy(&((*s_etat_processus)
! 4671: .semaphore_fork));
! 4672: # else
! 4673: sem_post((*s_etat_processus).semaphore_fork);
! 4674: sem_post(semaphore_gestionnaires_signaux);
! 4675: sem_destroy2(semaphore_gestionnaires_signaux,
! 4676: getpid(), SEM_SIGNAUX);
! 4677: sem_destroy3((*s_etat_processus).semphore_fork,
! 4678: getpid(), pthread_self(), SEM_FORK);
! 4679: # endif
! 4680:
! 4681: liberation_contexte_cas(s_etat_processus);
! 4682: liberation_queue_signaux(s_etat_processus);
! 4683:
! 4684: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4685: stackoverflow_deinstall_handler();
! 4686: # endif
! 4687:
! 4688: # ifdef HAVE_SIGSEGV_RECOVERY
! 4689: if (debug == d_faux)
! 4690: {
! 4691: sigsegv_deinstall_handler();
! 4692: }
! 4693: # endif
! 4694:
1.1 bertrand 4695: if ((message = messages(s_etat_processus))
4696: == NULL)
4697: {
4698: erreur = d_es_allocation_memoire;
4699:
4700: if ((*s_etat_processus).langue == 'F')
4701: {
4702: printf("+++Système : Mémoire "
4703: "insuffisante\n");
4704: }
4705: else
4706: {
4707: printf("+++System : Not enough "
4708: "memory\n");
4709: }
4710:
4711: return(EXIT_FAILURE);
4712: }
4713:
4714: printf("%s [%d]\n", message, (int) getpid());
4715: free(message);
4716:
4717: return(EXIT_FAILURE);
4718: }
4719:
4720: if ((*s_etat_processus).erreur_execution != d_ex)
4721: {
4722: if ((message = messages(s_etat_processus))
4723: == NULL)
4724: {
1.124 ! bertrand 4725: # ifndef SEMAPHORES_NOMMES
! 4726: sem_post(&((*s_etat_processus)
! 4727: .semaphore_fork));
! 4728: sem_post(&semaphore_gestionnaires_signaux);
! 4729: sem_destroy(
! 4730: &semaphore_gestionnaires_signaux);
! 4731: sem_destroy(&((*s_etat_processus)
! 4732: .semaphore_fork));
! 4733: # else
! 4734: sem_post((*s_etat_processus)
! 4735: .semaphore_fork);
! 4736: sem_post(semaphore_gestionnaires_signaux);
! 4737: sem_destroy2(
! 4738: semaphore_gestionnaires_signaux,
! 4739: getpid(), SEM_SIGNAUX);
! 4740: sem_destroy3((*s_etat_processus)
! 4741: .semphore_fork,
! 4742: getpid(), pthread_self(), SEM_FORK);
! 4743: # endif
! 4744:
! 4745: liberation_contexte_cas(s_etat_processus);
! 4746: liberation_queue_signaux(s_etat_processus);
! 4747:
! 4748: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4749: stackoverflow_deinstall_handler();
! 4750: # endif
! 4751:
! 4752: # ifdef HAVE_SIGSEGV_RECOVERY
! 4753: if (debug == d_faux)
! 4754: {
! 4755: sigsegv_deinstall_handler();
! 4756: }
! 4757: # endif
! 4758:
1.1 bertrand 4759: erreur = d_es_allocation_memoire;
4760:
4761: if ((*s_etat_processus).langue == 'F')
4762: {
4763: printf("+++Erreur : Mémoire "
4764: "insuffisante\n");
4765: }
4766: else
4767: {
4768: printf("+++Error : Not enough "
4769: "memory\n");
4770: }
4771:
4772: return(EXIT_FAILURE);
4773: }
4774:
4775: printf("%s [%d]\n", message, (int) getpid());
4776: free(message);
4777:
1.124 ! bertrand 4778: # ifndef SEMAPHORES_NOMMES
! 4779: sem_post(&((*s_etat_processus).semaphore_fork));
! 4780: sem_post(&semaphore_gestionnaires_signaux);
! 4781: sem_destroy(&semaphore_gestionnaires_signaux);
! 4782: sem_destroy(&((*s_etat_processus)
! 4783: .semaphore_fork));
! 4784: # else
! 4785: sem_post((*s_etat_processus).semaphore_fork);
! 4786: sem_post(semaphore_gestionnaires_signaux);
! 4787: sem_destroy2(semaphore_gestionnaires_signaux,
! 4788: getpid(), SEM_SIGNAUX);
! 4789: sem_destroy3((*s_etat_processus).semphore_fork,
! 4790: getpid(), pthread_self(), SEM_FORK);
! 4791: # endif
! 4792:
! 4793: liberation_contexte_cas(s_etat_processus);
! 4794: liberation_queue_signaux(s_etat_processus);
! 4795:
! 4796: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4797: stackoverflow_deinstall_handler();
! 4798: # endif
! 4799:
! 4800: # ifdef HAVE_SIGSEGV_RECOVERY
! 4801: if (debug == d_faux)
! 4802: {
! 4803: sigsegv_deinstall_handler();
! 4804: }
! 4805: # endif
! 4806:
1.1 bertrand 4807: return(EXIT_FAILURE);
4808: }
4809:
4810: if (depilement(s_etat_processus,
4811: &((*s_etat_processus).l_base_pile),
4812: &s_objet) == d_erreur)
4813: {
4814: if ((message = messages(s_etat_processus))
4815: == NULL)
4816: {
1.124 ! bertrand 4817: # ifndef SEMAPHORES_NOMMES
! 4818: sem_post(&((*s_etat_processus)
! 4819: .semaphore_fork));
! 4820: sem_post(&semaphore_gestionnaires_signaux);
! 4821: sem_destroy(
! 4822: &semaphore_gestionnaires_signaux);
! 4823: sem_destroy(&((*s_etat_processus)
! 4824: .semaphore_fork));
! 4825: # else
! 4826: sem_post((*s_etat_processus)
! 4827: .semaphore_fork);
! 4828: sem_post(semaphore_gestionnaires_signaux);
! 4829: sem_destroy2(
! 4830: semaphore_gestionnaires_signaux,
! 4831: getpid(), SEM_SIGNAUX);
! 4832: sem_destroy3((*s_etat_processus)
! 4833: .semphore_fork,
! 4834: getpid(), pthread_self(), SEM_FORK);
! 4835: # endif
! 4836:
! 4837: liberation_contexte_cas(s_etat_processus);
! 4838: liberation_queue_signaux(s_etat_processus);
! 4839:
! 4840: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4841: stackoverflow_deinstall_handler();
! 4842: # endif
! 4843:
! 4844: # ifdef HAVE_SIGSEGV_RECOVERY
! 4845: if (debug == d_faux)
! 4846: {
! 4847: sigsegv_deinstall_handler();
! 4848: }
! 4849: # endif
! 4850:
! 4851: erreur = d_es_allocation_memoire;
1.1 bertrand 4852: erreur = d_es_allocation_memoire;
4853:
4854: if ((*s_etat_processus).langue == 'F')
4855: {
4856: printf("+++Erreur : Mémoire "
4857: "insuffisante\n");
4858: }
4859: else
4860: {
4861: printf("+++Error : Not enough "
4862: "memory\n");
4863: }
4864:
4865: return(EXIT_FAILURE);
4866: }
4867:
4868: printf("%s [%d]\n", message, (int) getpid());
4869: free(message);
4870:
1.124 ! bertrand 4871: # ifndef SEMAPHORES_NOMMES
! 4872: sem_post(&((*s_etat_processus).semaphore_fork));
! 4873: sem_post(&semaphore_gestionnaires_signaux);
! 4874: sem_destroy(&semaphore_gestionnaires_signaux);
! 4875: sem_destroy(&((*s_etat_processus)
! 4876: .semaphore_fork));
! 4877: # else
! 4878: sem_post((*s_etat_processus).semaphore_fork);
! 4879: sem_post(semaphore_gestionnaires_signaux);
! 4880: sem_destroy2(semaphore_gestionnaires_signaux,
! 4881: getpid(), SEM_SIGNAUX);
! 4882: sem_destroy3((*s_etat_processus).semphore_fork,
! 4883: getpid(), pthread_self(), SEM_FORK);
! 4884: # endif
! 4885:
! 4886: liberation_contexte_cas(s_etat_processus);
! 4887: liberation_queue_signaux(s_etat_processus);
! 4888:
! 4889: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4890: stackoverflow_deinstall_handler();
! 4891: # endif
! 4892:
! 4893: # ifdef HAVE_SIGSEGV_RECOVERY
! 4894: if (debug == d_faux)
! 4895: {
! 4896: sigsegv_deinstall_handler();
! 4897: }
! 4898: # endif
! 4899:
1.1 bertrand 4900: return(EXIT_FAILURE);
4901: }
4902:
4903: if (evaluation(s_etat_processus, s_objet, 'E')
4904: == d_erreur)
4905: {
4906: if ((*s_etat_processus).erreur_systeme != d_es)
4907: {
4908: if ((message = messages(s_etat_processus))
4909: == NULL)
4910: {
1.124 ! bertrand 4911: # ifndef SEMAPHORES_NOMMES
! 4912: sem_post(&((*s_etat_processus)
! 4913: .semaphore_fork));
! 4914: sem_post(
! 4915: &semaphore_gestionnaires_signaux
! 4916: );
! 4917: sem_destroy(
! 4918: &semaphore_gestionnaires_signaux
! 4919: );
! 4920: sem_destroy(&((*s_etat_processus)
! 4921: .semaphore_fork));
! 4922: # else
! 4923: sem_post((*s_etat_processus)
! 4924: .semaphore_fork);
! 4925: sem_post(
! 4926: semaphore_gestionnaires_signaux
! 4927: );
! 4928: sem_destroy2(
! 4929: semaphore_gestionnaires_signaux,
! 4930: getpid(), SEM_SIGNAUX);
! 4931: sem_destroy3((*s_etat_processus)
! 4932: .semphore_fork, getpid(),
! 4933: pthread_self(), SEM_FORK);
! 4934: # endif
! 4935:
! 4936: liberation_contexte_cas(s_etat_processus);
! 4937: liberation_queue_signaux(s_etat_processus);
! 4938:
! 4939: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4940: stackoverflow_deinstall_handler();
! 4941: # endif
! 4942:
! 4943: # ifdef HAVE_SIGSEGV_RECOVERY
! 4944: if (debug == d_faux)
! 4945: {
! 4946: sigsegv_deinstall_handler();
! 4947: }
! 4948: # endif
! 4949:
1.1 bertrand 4950: erreur = d_es_allocation_memoire;
4951:
4952: if ((*s_etat_processus).langue == 'F')
4953: {
4954: printf("+++Système : Mémoire "
4955: "insuffisante\n");
4956: }
4957: else
4958: {
4959: printf("+++System : Not enough "
4960: "memory\n");
4961: }
4962:
4963: return(EXIT_FAILURE);
4964: }
4965:
4966: printf("%s [%d]\n", message,
4967: (int) getpid());
4968: free(message);
4969:
1.124 ! bertrand 4970: # ifndef SEMAPHORES_NOMMES
! 4971: sem_post(&((*s_etat_processus)
! 4972: .semaphore_fork));
! 4973: sem_post(&semaphore_gestionnaires_signaux);
! 4974: sem_destroy(
! 4975: &semaphore_gestionnaires_signaux);
! 4976: sem_destroy(&((*s_etat_processus)
! 4977: .semaphore_fork));
! 4978: # else
! 4979: sem_post((*s_etat_processus)
! 4980: .semaphore_fork);
! 4981: sem_post(semaphore_gestionnaires_signaux);
! 4982: sem_destroy2(
! 4983: semaphore_gestionnaires_signaux,
! 4984: getpid(), SEM_SIGNAUX);
! 4985: sem_destroy3((*s_etat_processus)
! 4986: .semphore_fork,
! 4987: getpid(), pthread_self(), SEM_FORK);
! 4988: # endif
! 4989:
! 4990: liberation_contexte_cas(s_etat_processus);
! 4991: liberation_queue_signaux(s_etat_processus);
! 4992:
! 4993: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 4994: stackoverflow_deinstall_handler();
! 4995: # endif
! 4996:
! 4997: # ifdef HAVE_SIGSEGV_RECOVERY
! 4998: if (debug == d_faux)
! 4999: {
! 5000: sigsegv_deinstall_handler();
! 5001: }
! 5002: # endif
! 5003:
! 5004: erreur = d_es_allocation_memoire;
1.1 bertrand 5005: return(EXIT_FAILURE);
5006: }
5007:
5008: if ((*s_etat_processus).erreur_execution
5009: != d_ex)
5010: {
5011: if ((message = messages(s_etat_processus))
5012: == NULL)
5013: {
1.124 ! bertrand 5014: # ifndef SEMAPHORES_NOMMES
! 5015: sem_post(&((*s_etat_processus)
! 5016: .semaphore_fork));
! 5017: sem_post(
! 5018: &semaphore_gestionnaires_signaux
! 5019: );
! 5020: sem_destroy(
! 5021: &semaphore_gestionnaires_signaux
! 5022: );
! 5023: sem_destroy(&((*s_etat_processus)
! 5024: .semaphore_fork));
! 5025: # else
! 5026: sem_post((*s_etat_processus)
! 5027: .semaphore_fork);
! 5028: sem_post(
! 5029: semaphore_gestionnaires_signaux
! 5030: );
! 5031: sem_destroy2(
! 5032: semaphore_gestionnaires_signaux,
! 5033: getpid(), SEM_SIGNAUX);
! 5034: sem_destroy3((*s_etat_processus)
! 5035: .semphore_fork, getpid(),
! 5036: pthread_self(), SEM_FORK);
! 5037: # endif
! 5038:
! 5039: liberation_contexte_cas(s_etat_processus);
! 5040: liberation_queue_signaux(s_etat_processus);
! 5041:
! 5042: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 5043: stackoverflow_deinstall_handler();
! 5044: # endif
! 5045:
! 5046: # ifdef HAVE_SIGSEGV_RECOVERY
! 5047: if (debug == d_faux)
! 5048: {
! 5049: sigsegv_deinstall_handler();
! 5050: }
! 5051: # endif
! 5052:
1.1 bertrand 5053: erreur = d_es_allocation_memoire;
5054:
5055: if ((*s_etat_processus).langue == 'F')
5056: {
5057: printf("+++Erreur : Mémoire "
5058: "insuffisante\n");
5059: }
5060: else
5061: {
5062: printf("+++Error : Not enough "
5063: "memory\n");
5064: }
5065:
5066: return(EXIT_FAILURE);
5067: }
5068:
5069: printf("%s [%d]\n", message,
5070: (int) getpid());
5071: free(message);
5072:
1.124 ! bertrand 5073: # ifndef SEMAPHORES_NOMMES
! 5074: sem_post(&((*s_etat_processus)
! 5075: .semaphore_fork));
! 5076: sem_post(&semaphore_gestionnaires_signaux);
! 5077: sem_destroy(
! 5078: &semaphore_gestionnaires_signaux);
! 5079: sem_destroy(&((*s_etat_processus)
! 5080: .semaphore_fork));
! 5081: # else
! 5082: sem_post((*s_etat_processus)
! 5083: .semaphore_fork);
! 5084: sem_post(semaphore_gestionnaires_signaux);
! 5085: sem_destroy2(
! 5086: semaphore_gestionnaires_signaux,
! 5087: getpid(), SEM_SIGNAUX);
! 5088: sem_destroy3((*s_etat_processus)
! 5089: .semphore_fork,
! 5090: getpid(), pthread_self(), SEM_FORK);
! 5091: # endif
! 5092:
! 5093: liberation_contexte_cas(s_etat_processus);
! 5094: liberation_queue_signaux(s_etat_processus);
! 5095:
! 5096: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 5097: stackoverflow_deinstall_handler();
! 5098: # endif
! 5099:
! 5100: # ifdef HAVE_SIGSEGV_RECOVERY
! 5101: if (debug == d_faux)
! 5102: {
! 5103: sigsegv_deinstall_handler();
! 5104: }
! 5105: # endif
! 5106:
1.1 bertrand 5107: return(EXIT_FAILURE);
5108: }
5109: }
5110:
5111: (*s_etat_processus).instruction_courante = NULL;
5112: liberation(s_etat_processus, s_objet);
5113:
5114: free(arguments);
5115: }
5116:
1.13 bertrand 5117: if (option_a == d_vrai)
1.1 bertrand 5118: {
1.13 bertrand 5119: fprintf(stdout, "%s\n", (*s_etat_processus)
5120: .definitions_chainees);
1.1 bertrand 5121: }
1.13 bertrand 5122: else
5123: {
5124: if (option_D == d_vrai)
5125: {
5126: lancement_daemon(s_etat_processus);
5127: }
1.1 bertrand 5128:
1.13 bertrand 5129: if (option_p == d_faux)
1.1 bertrand 5130: {
1.13 bertrand 5131: if (setjmp(contexte_initial) == 0)
5132: {
5133: erreur = sequenceur(s_etat_processus);
1.80 bertrand 5134:
5135: if (erreur == d_absence_erreur)
5136: {
5137: if (((*s_etat_processus).var_volatile_alarme
5138: == 0) && ((*s_etat_processus)
5139: .arret_depuis_abort == 0) &&
5140: ((*s_etat_processus).at_exit
5141: != NULL))
5142: {
5143: erreur = evaluation(s_etat_processus,
5144: (*s_etat_processus).at_exit,
5145: 'E');
5146: }
5147: }
1.13 bertrand 5148: }
1.1 bertrand 5149: }
1.13 bertrand 5150: else
1.1 bertrand 5151: {
1.13 bertrand 5152: if (setjmp(contexte_initial) == 0)
5153: {
5154: erreur = sequenceur_optimise(s_etat_processus);
1.19 bertrand 5155:
1.80 bertrand 5156: if (erreur == d_absence_erreur)
5157: {
5158: if (((*s_etat_processus).var_volatile_alarme
5159: == 0) && ((*s_etat_processus)
5160: .arret_depuis_abort == 0) &&
5161: ((*s_etat_processus).at_exit
5162: != NULL))
5163: {
5164: erreur = evaluation(s_etat_processus,
5165: (*s_etat_processus).at_exit,
5166: 'E');
5167: }
5168: }
1.21 bertrand 5169: }
1.19 bertrand 5170: }
1.34 bertrand 5171: }
1.19 bertrand 5172:
1.117 bertrand 5173: for(i = 0; i < (*s_etat_processus).sections_critiques; i++)
5174: {
5175: pthread_mutex_unlock(&mutex_sections_critiques);
5176: }
5177:
1.34 bertrand 5178: liberation(s_etat_processus, (*s_etat_processus).at_exit);
5179: liberation(s_etat_processus, (*s_etat_processus).at_poke);
1.1 bertrand 5180:
5181: if ((*s_etat_processus).generateur_aleatoire != NULL)
5182: {
5183: liberation_generateur_aleatoire(s_etat_processus);
5184: }
5185:
5186: l_element_courant = (*s_etat_processus).liste_mutexes;
5187: while(l_element_courant != NULL)
5188: {
5189: liberation(s_etat_processus,
5190: (*((struct_liste_chainee *)
5191: l_element_courant)).donnee);
5192: l_element_suivant = (*((struct_liste_chainee *)
5193: l_element_courant)).suivant;
5194: free((struct_liste_chainee *) l_element_courant);
5195: l_element_courant = l_element_suivant;
5196: }
5197:
5198: /*
5199: * Arrêt des processus fils
5200: */
5201:
5202: if ((*s_etat_processus).presence_fusible == d_vrai)
5203: {
5204: pthread_cancel((*s_etat_processus).thread_fusible);
5205: }
5206:
5207: pthread_mutex_lock(&((*s_etat_processus).mutex));
5208:
5209: l_element_courant = (void *) (*s_etat_processus)
5210: .l_base_pile_processus;
5211:
5212: while(l_element_courant != NULL)
5213: {
5214: if ((*s_etat_processus).debug == d_vrai)
5215: {
5216: if (((*s_etat_processus).type_debug &
5217: d_debug_processus) != 0)
5218: {
5219: if ((*(*((struct_processus_fils *)
5220: (*(*((struct_liste_chainee *)
5221: l_element_courant)).donnee)
5222: .objet)).thread)
5223: .processus_detache == d_vrai)
5224: {
5225: if ((*s_etat_processus).langue == 'F')
5226: {
5227: printf("[%d] Signalement pour arrêt du "
5228: "processus %d\n",
5229: (int) getpid(), (int)
5230: (*(*((struct_processus_fils *)
5231: (*(*((struct_liste_chainee *)
5232: l_element_courant)).donnee)
5233: .objet)).thread).pid);
5234: }
5235: else
5236: {
5237: printf("[%d] Send stop signal to "
5238: "process %d\n",
5239: (int) getpid(), (int)
5240: (*(*((struct_processus_fils *)
5241: (*(*((struct_liste_chainee *)
5242: l_element_courant)).donnee)
5243: .objet)).thread).pid);
5244: }
5245: }
5246: else
5247: {
5248: if ((*s_etat_processus).langue == 'F')
5249: {
5250: printf("[%d] Signalement pour arrêt du "
5251: "thread %llu\n", (int) getpid(),
5252: (unsigned long long)
5253: (*(*((struct_processus_fils *)
5254: (*(*((struct_liste_chainee *)
5255: l_element_courant)).donnee)
5256: .objet)).thread).tid);
5257: }
5258: else
5259: {
5260: printf("[%d] Send stop signal to "
5261: "thread %llu\n",
5262: (int) getpid(),
5263: (unsigned long long)
5264: (*(*((struct_processus_fils *)
5265: (*(*((struct_liste_chainee *)
5266: l_element_courant)).donnee)
5267: .objet)).thread).tid);
5268: }
5269: }
5270: }
5271: }
5272:
5273: if ((*(*((struct_processus_fils *)
5274: (*(*((struct_liste_chainee *)
5275: l_element_courant)).donnee).objet))
5276: .thread).processus_detache == d_vrai)
5277: {
5278: if ((*s_etat_processus).var_volatile_alarme != 0)
5279: {
1.83 bertrand 5280: envoi_signal_processus(
5281: (*(*((struct_processus_fils *)
1.1 bertrand 5282: (*(*((struct_liste_chainee *)
5283: l_element_courant)).donnee).objet))
1.83 bertrand 5284: .thread).pid, rpl_sigurg);
1.1 bertrand 5285: }
5286: else
5287: {
1.22 bertrand 5288: if ((*s_etat_processus).arret_depuis_abort
5289: == -1)
5290: {
1.83 bertrand 5291: envoi_signal_processus(
5292: (*(*((struct_processus_fils *)
1.22 bertrand 5293: (*(*((struct_liste_chainee *)
5294: l_element_courant)).donnee).objet))
1.83 bertrand 5295: .thread).pid, rpl_sigabort);
1.22 bertrand 5296: }
5297: else
5298: {
1.83 bertrand 5299: envoi_signal_processus(
5300: (*(*((struct_processus_fils *)
1.22 bertrand 5301: (*(*((struct_liste_chainee *)
5302: l_element_courant)).donnee).objet))
1.83 bertrand 5303: .thread).pid, rpl_sigstop);
1.22 bertrand 5304: }
1.1 bertrand 5305: }
5306: }
5307: else
5308: {
5309: pthread_mutex_lock(&((*(*((struct_processus_fils *)
5310: (*(*((struct_liste_chainee *)
5311: l_element_courant)).donnee).objet)).thread)
5312: .mutex));
5313:
5314: if ((*(*((struct_processus_fils *)
5315: (*(*((struct_liste_chainee *)
5316: l_element_courant)).donnee).objet)).thread)
5317: .thread_actif == d_vrai)
5318: {
5319: if ((*s_etat_processus).var_volatile_alarme
5320: != 0)
5321: {
1.83 bertrand 5322: envoi_signal_thread(
5323: (*(*((struct_processus_fils *)
1.1 bertrand 5324: (*(*((struct_liste_chainee *)
5325: l_element_courant)).donnee).objet))
1.83 bertrand 5326: .thread).tid, rpl_sigurg);
1.1 bertrand 5327: }
5328: else
5329: {
1.22 bertrand 5330: if ((*s_etat_processus).arret_depuis_abort
5331: == -1)
5332: {
1.83 bertrand 5333: envoi_signal_thread(
1.22 bertrand 5334: (*(*((struct_processus_fils *)
5335: (*(*((struct_liste_chainee *)
5336: l_element_courant)).donnee)
5337: .objet)).thread).tid,
1.83 bertrand 5338: rpl_sigabort);
1.22 bertrand 5339: }
5340: else
5341: {
1.83 bertrand 5342: envoi_signal_thread(
1.22 bertrand 5343: (*(*((struct_processus_fils *)
5344: (*(*((struct_liste_chainee *)
5345: l_element_courant)).donnee)
5346: .objet)).thread).tid,
1.83 bertrand 5347: rpl_sigstop);
1.22 bertrand 5348: }
1.1 bertrand 5349: }
5350: }
5351:
5352: pthread_mutex_unlock(
5353: &((*(*((struct_processus_fils *)
5354: (*(*((struct_liste_chainee *)
5355: l_element_courant)).donnee).objet)).thread)
5356: .mutex));
5357: }
5358:
5359: l_element_courant = (*((struct_liste_chainee *)
5360: l_element_courant)).suivant;
5361: }
5362:
5363: /*
5364: * Attente de la fin de tous les processus fils
5365: */
5366:
5367: for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
5368: (*s_etat_processus).masque_interruptions[i++]
5369: = 'I');
5370:
5371: attente.tv_sec = 0;
5372: attente.tv_nsec = GRANULARITE_us * 1000;
5373:
5374: while((*s_etat_processus).l_base_pile_processus != NULL)
5375: {
5376: l_element_courant = (void *)
5377: (*s_etat_processus).l_base_pile_processus;
5378:
5379: for(i = 0; i < (unsigned long)
5380: (*(*((struct_processus_fils *)
5381: (*(*((struct_liste_chainee *)
5382: l_element_courant)).donnee).objet)).thread)
5383: .nombre_objets_dans_pipe; i++)
5384: {
5385: if ((s_objet = lecture_pipe(
5386: s_etat_processus,
5387: (*(*((struct_processus_fils *)
5388: (*(*((struct_liste_chainee *)
5389: l_element_courant)).donnee).objet)).thread)
5390: .pipe_objets[0])) != NULL)
5391: {
5392: liberation(s_etat_processus, s_objet);
5393:
5394: (*(*((struct_processus_fils *)
5395: (*(*((struct_liste_chainee *)
5396: l_element_courant)).donnee).objet))
5397: .thread).nombre_objets_dans_pipe--;
5398:
5399: action.sa_handler = SIG_IGN;
1.94 bertrand 5400: action.sa_flags = 0;
1.1 bertrand 5401:
5402: if (sigaction(SIGPIPE, &action, ®istre)
5403: != 0)
5404: {
1.124 ! bertrand 5405: # ifndef SEMAPHORES_NOMMES
! 5406: sem_post(&((*s_etat_processus)
! 5407: .semaphore_fork));
! 5408: sem_post(
! 5409: &semaphore_gestionnaires_signaux
! 5410: );
! 5411: sem_destroy(
! 5412: &semaphore_gestionnaires_signaux
! 5413: );
! 5414: sem_destroy(&((*s_etat_processus)
! 5415: .semaphore_fork));
! 5416: # else
! 5417: sem_post((*s_etat_processus)
! 5418: .semaphore_fork);
! 5419: sem_post(
! 5420: semaphore_gestionnaires_signaux
! 5421: );
! 5422: sem_destroy2(
! 5423: semaphore_gestionnaires_signaux,
! 5424: getpid(), SEM_SIGNAUX);
! 5425: sem_destroy3((*s_etat_processus)
! 5426: .semphore_fork, getpid(),
! 5427: pthread_self(), SEM_FORK);
! 5428: # endif
! 5429:
! 5430: liberation_contexte_cas(s_etat_processus);
! 5431: liberation_queue_signaux(s_etat_processus);
! 5432:
! 5433: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 5434: stackoverflow_deinstall_handler();
! 5435: # endif
! 5436:
! 5437: # ifdef HAVE_SIGSEGV_RECOVERY
! 5438: if (debug == d_faux)
! 5439: {
! 5440: sigsegv_deinstall_handler();
! 5441: }
! 5442: # endif
! 5443:
1.1 bertrand 5444: pthread_mutex_unlock(
5445: &((*s_etat_processus).mutex));
5446: return(EXIT_FAILURE);
5447: }
5448:
5449: while((longueur_ecriture =
5450: write_atomic(s_etat_processus,
5451: (*(*((struct_processus_fils *)
5452: (*(*((struct_liste_chainee *)
5453: l_element_courant)).donnee).objet))
5454: .thread).pipe_nombre_injections[1], "+",
5455: sizeof(unsigned char))) !=
5456: sizeof(unsigned char))
5457: {
5458: if (longueur_ecriture == -1)
5459: {
5460: // Le processus n'existe plus.
5461: break;
5462: }
5463: }
5464:
5465: if (sigaction(SIGPIPE, ®istre, NULL)
5466: != 0)
5467: {
1.124 ! bertrand 5468: # ifndef SEMAPHORES_NOMMES
! 5469: sem_post(&((*s_etat_processus)
! 5470: .semaphore_fork));
! 5471: sem_post(
! 5472: &semaphore_gestionnaires_signaux
! 5473: );
! 5474: sem_destroy(
! 5475: &semaphore_gestionnaires_signaux
! 5476: );
! 5477: sem_destroy(&((*s_etat_processus)
! 5478: .semaphore_fork));
! 5479: # else
! 5480: sem_post((*s_etat_processus)
! 5481: .semaphore_fork);
! 5482: sem_post(
! 5483: semaphore_gestionnaires_signaux
! 5484: );
! 5485: sem_destroy2(
! 5486: semaphore_gestionnaires_signaux,
! 5487: getpid(), SEM_SIGNAUX);
! 5488: sem_destroy3((*s_etat_processus)
! 5489: .semphore_fork, getpid(),
! 5490: pthread_self(), SEM_FORK);
! 5491: # endif
! 5492:
! 5493: liberation_contexte_cas(s_etat_processus);
! 5494: liberation_queue_signaux(s_etat_processus);
! 5495:
! 5496: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
! 5497: stackoverflow_deinstall_handler();
! 5498: # endif
! 5499:
! 5500: # ifdef HAVE_SIGSEGV_RECOVERY
! 5501: if (debug == d_faux)
! 5502: {
! 5503: sigsegv_deinstall_handler();
! 5504: }
! 5505: # endif
! 5506:
1.1 bertrand 5507: pthread_mutex_unlock(
5508: &((*s_etat_processus).mutex));
5509: return(EXIT_FAILURE);
5510: }
5511: }
5512: }
5513:
5514: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1.23 bertrand 5515:
5516: if ((*s_etat_processus)
5517: .nombre_interruptions_non_affectees != 0)
5518: {
5519: affectation_interruptions_logicielles(
5520: s_etat_processus);
5521: }
5522:
1.1 bertrand 5523: nanosleep(&attente, NULL);
1.85 bertrand 5524: scrutation_interruptions(s_etat_processus);
1.1 bertrand 5525: pthread_mutex_lock(&((*s_etat_processus).mutex));
5526: }
5527:
5528: pthread_mutex_unlock(&((*s_etat_processus).mutex));
5529:
5530: erreur_historique = write_history(
5531: (*s_etat_processus).nom_fichier_historique);
5532: clear_history();
5533:
5534: if (erreur_historique != 0)
5535: {
5536: if ((*s_etat_processus).langue == 'F')
5537: {
5538: printf("+++Erreur : L'historique ne peut être "
5539: "écrit\n");
5540: }
5541: else
5542: {
5543: printf("+++Error : History cannot be "
5544: "written\n");
5545: }
5546:
5547: if (test_cfsf(s_etat_processus, 51) == d_faux)
5548: {
5549: printf("%s", ds_beep);
5550: }
5551: }
5552:
5553: free((*s_etat_processus).nom_fichier_historique);
5554:
5555: if (((*s_etat_processus).core == d_vrai) &&
5556: (erreur == d_erreur) &&
5557: ((*s_etat_processus).var_volatile_traitement_sigint
5558: == 0))
5559: {
5560: printf("\n");
5561:
5562: if ((*s_etat_processus).langue == 'F')
5563: {
5564: printf("+++Information : Génération du fichier "
5565: "rpl-core [%d]\n", (int) getpid());
5566: }
5567: else
5568: {
5569: printf("+++Information : Writing rpl-core "
5570: "file [%d]\n", (int) getpid());
5571: }
5572:
5573: rplcore(s_etat_processus);
5574:
5575: if ((*s_etat_processus).langue == 'F')
5576: {
5577: printf("+++Information : Processus tracé [%d]\n",
5578: (int) getpid());
5579: }
5580: else
5581: {
5582: printf("+++Information : Done [%d]\n",
5583: (int) getpid());
5584: }
5585:
5586: printf("\n");
5587: }
5588:
5589: free((*s_etat_processus).definitions_chainees);
5590:
5591: /*
5592: * Libération de l'arbre des instructions
5593: */
5594:
5595: liberation_arbre_instructions(s_etat_processus,
5596: (*s_etat_processus).arbre_instructions);
5597: free((*s_etat_processus).pointeurs_caracteres);
5598:
5599: if ((*s_etat_processus).entree_standard != NULL)
5600: {
5601: pclose((*s_etat_processus).entree_standard);
5602: (*s_etat_processus).entree_standard = NULL;
5603: }
5604:
5605: if ((*s_etat_processus).nom_fichier_impression != NULL)
5606: {
5607: if (test_cfsf(s_etat_processus, 51) == d_faux)
5608: {
5609: printf("%s", ds_beep);
5610: }
5611:
5612: if ((*s_etat_processus).langue == 'F')
5613: {
5614: printf("+++Attention : Queue d'impression "
5615: "non vide !\n");
5616: }
5617: else
5618: {
5619: printf("+++Warning : Non empty printing "
5620: "spool queue !\n");
5621: }
5622:
5623: instruction_erase(s_etat_processus);
5624: }
5625:
5626: if ((*s_etat_processus).fichiers_graphiques != NULL)
5627: {
5628: instruction_cllcd(s_etat_processus);
5629: }
5630:
5631: liberation(s_etat_processus, (*s_etat_processus).indep);
5632: liberation(s_etat_processus, (*s_etat_processus).depend);
5633:
5634: free((*s_etat_processus).label_x);
5635: free((*s_etat_processus).label_y);
5636: free((*s_etat_processus).label_z);
5637: free((*s_etat_processus).titre);
5638: free((*s_etat_processus).legende);
5639:
5640: liberation(s_etat_processus, (*s_etat_processus)
5641: .parametres_courbes_de_niveau);
5642:
5643: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
5644: {
5645: liberation(s_etat_processus,
5646: (*s_etat_processus).corps_interruptions[i]);
5647:
5648: l_element_courant = (*s_etat_processus)
5649: .pile_origine_interruptions[i];
5650:
5651: while(l_element_courant != NULL)
5652: {
5653: l_element_suivant = (*((struct_liste_chainee *)
5654: l_element_courant)).suivant;
5655:
5656: liberation(s_etat_processus,
5657: (*((struct_liste_chainee *)
5658: l_element_courant)).donnee);
5659: free(l_element_courant);
5660:
5661: l_element_courant = l_element_suivant;
5662: }
5663: }
5664:
5665: if ((*s_etat_processus).instruction_derniere_erreur
5666: != NULL)
5667: {
5668: free((*s_etat_processus).instruction_derniere_erreur);
5669: (*s_etat_processus).instruction_derniere_erreur = NULL;
5670: }
5671:
5672: /*
5673: * Le pointeur s_etat_processus.nom_fichier_source est
5674: * alloué par le système. Il ne faut donc pas
5675: * le libérer...
5676: */
5677:
1.66 bertrand 5678: liberation_arbre_variables(s_etat_processus,
5679: (*s_etat_processus).s_arbre_variables, d_vrai);
5680: free((*s_etat_processus).pointeurs_caracteres_variables);
1.1 bertrand 5681:
1.121 bertrand 5682: l_element_statique_courant = (*s_etat_processus)
5683: .l_liste_variables_statiques;
5684:
5685: while(l_element_statique_courant != NULL)
5686: {
5687: l_element_statique_suivant =
5688: (*l_element_statique_courant).suivant;
5689: free(l_element_statique_courant);
5690: l_element_statique_courant = l_element_statique_suivant;
5691: }
5692:
1.1 bertrand 5693: for(i = 0; i < (*((*s_etat_processus)
5694: .s_liste_variables_partagees)).nombre_variables;
5695: i++)
5696: {
5697: liberation(s_etat_processus, (*((*s_etat_processus)
5698: .s_liste_variables_partagees)).table[i].objet);
5699: free((*((*s_etat_processus)
5700: .s_liste_variables_partagees)).table[i].nom);
5701: }
5702:
5703: free((struct_variable_partagee *)
5704: (*((*s_etat_processus).s_liste_variables_partagees))
5705: .table);
5706:
5707: /*
5708: * Si resultats est non nul, rplinit a été appelé
5709: * depuis rpl() [librpl] et non main().
5710: * On copie alors le contenu de la * pile dans un
5711: * tableau **resultats dont le pointeur de base a
5712: * été alloué dans rpl().
5713: */
5714:
5715: if (resultats != NULL)
5716: {
5717: if ((*resultats) != NULL)
5718: {
5719: free((*resultats));
5720:
5721: if (((*resultats) = malloc(((*s_etat_processus)
5722: .hauteur_pile_operationnelle + 1)
5723: * sizeof(unsigned char **))) != NULL)
5724: {
5725: (*resultats)[(*s_etat_processus)
5726: .hauteur_pile_operationnelle] = NULL;
5727: l_element_courant = (void *) (*s_etat_processus)
5728: .l_base_pile;
5729:
5730: for(i = 0; i < (*s_etat_processus)
5731: .hauteur_pile_operationnelle; i++)
5732: {
5733: if (l_element_courant != NULL)
5734: {
5735: (*resultats)[i] =
5736: formateur(s_etat_processus,
5737: 0, (*((struct_liste_chainee *)
5738: l_element_courant)).donnee);
5739:
5740: if ((*resultats)[i] == NULL)
5741: {
5742: i = (*s_etat_processus).
5743: hauteur_pile_operationnelle;
5744: }
5745: else
5746: {
5747: l_element_suivant =
5748: (*((struct_liste_chainee *)
5749: l_element_courant)).suivant;
5750: }
5751: }
5752: }
5753: }
5754: else
5755: {
5756: (*resultats) = NULL;
5757: erreur = d_es_allocation_memoire;
5758: }
5759: }
5760: }
5761:
5762: l_element_courant = (void *) (*s_etat_processus)
5763: .l_base_pile;
5764: while(l_element_courant != NULL)
5765: {
5766: l_element_suivant = (*((struct_liste_chainee *)
5767: l_element_courant)).suivant;
5768:
5769: liberation(s_etat_processus,
5770: (*((struct_liste_chainee *)
5771: l_element_courant)).donnee);
5772: free((struct_liste_chainee *) l_element_courant);
5773:
5774: l_element_courant = l_element_suivant;
5775: }
5776:
5777: l_element_courant = (void *) (*s_etat_processus)
5778: .l_base_pile_contextes;
5779: while(l_element_courant != NULL)
5780: {
5781: l_element_suivant = (*((struct_liste_chainee *)
5782: l_element_courant)).suivant;
5783:
5784: liberation(s_etat_processus,
5785: (*((struct_liste_chainee *)
5786: l_element_courant)).donnee);
5787: free((struct_liste_chainee *) l_element_courant);
5788:
5789: l_element_courant = l_element_suivant;
5790: }
5791:
5792: l_element_courant = (void *) (*s_etat_processus)
5793: .l_base_pile_taille_contextes;
5794: while(l_element_courant != NULL)
5795: {
5796: l_element_suivant = (*((struct_liste_chainee *)
5797: l_element_courant)).suivant;
5798:
5799: liberation(s_etat_processus,
5800: (*((struct_liste_chainee *)
5801: l_element_courant)).donnee);
5802: free((struct_liste_chainee *) l_element_courant);
5803:
5804: l_element_courant = l_element_suivant;
5805: }
5806:
5807: for(i = 0; i < (*s_etat_processus)
5808: .nombre_instructions_externes; i++)
5809: {
5810: free((*s_etat_processus).s_instructions_externes[i]
5811: .nom);
5812: free((*s_etat_processus).s_instructions_externes[i]
5813: .nom_bibliotheque);
5814: }
5815:
5816: if ((*s_etat_processus).nombre_instructions_externes != 0)
5817: {
5818: free((*s_etat_processus).s_instructions_externes);
5819: }
5820:
5821: l_element_courant = (void *) (*s_etat_processus)
5822: .s_bibliotheques;
5823:
5824: while(l_element_courant != NULL)
5825: {
5826: l_element_suivant = (*((struct_liste_chainee *)
5827: l_element_courant)).suivant;
5828:
5829: free((*((struct_bibliotheque *)
5830: (*((struct_liste_chainee *)
5831: l_element_courant)).donnee)).nom);
5832: dlclose((*((struct_bibliotheque *)
5833: (*((struct_liste_chainee *)
5834: l_element_courant)).donnee)).descripteur);
5835: free((*((struct_liste_chainee *) l_element_courant))
5836: .donnee);
5837: free(l_element_courant);
5838:
5839: l_element_courant = l_element_suivant;
5840: }
5841:
5842: l_element_courant = (void *) (*s_etat_processus)
5843: .l_base_pile_last;
5844: while(l_element_courant != NULL)
5845: {
5846: l_element_suivant = (*((struct_liste_chainee *)
5847: l_element_courant)).suivant;
5848:
5849: liberation(s_etat_processus,
5850: (*((struct_liste_chainee *)
5851: l_element_courant)).donnee);
5852: free((struct_liste_chainee *) l_element_courant);
5853:
5854: l_element_courant = l_element_suivant;
5855: }
5856:
5857: l_element_courant = (void *) (*s_etat_processus)
5858: .l_base_pile_systeme;
5859: while(l_element_courant != NULL)
5860: {
5861: l_element_suivant = (*((struct_liste_pile_systeme *)
5862: l_element_courant)).suivant;
5863:
5864: liberation(s_etat_processus,
5865: (*((struct_liste_pile_systeme *)
5866: l_element_courant)).indice_boucle);
5867: liberation(s_etat_processus,
5868: (*((struct_liste_pile_systeme *)
5869: l_element_courant)).limite_indice_boucle);
5870: liberation(s_etat_processus,
5871: (*((struct_liste_pile_systeme *)
5872: l_element_courant)).objet_de_test);
5873:
5874: if ((*((struct_liste_pile_systeme *)
5875: l_element_courant)).nom_variable != NULL)
5876: {
5877: free((*((struct_liste_pile_systeme *)
5878: l_element_courant)).nom_variable);
5879: }
5880:
5881: free((struct_liste_pile_systeme *)
5882: l_element_courant);
5883:
5884: l_element_courant = l_element_suivant;
5885: }
5886:
5887: l_element_courant = (void *)
5888: (*s_etat_processus).s_fichiers;
5889: while(l_element_courant != NULL)
5890: {
5891: l_element_suivant = (*((struct_liste_chainee *)
5892: l_element_courant)).suivant;
5893:
5894: fclose((*((struct_descripteur_fichier *)
5895: (*((struct_liste_chainee *)
5896: l_element_courant)).donnee))
1.12 bertrand 5897: .descripteur_c);
5898:
5899: if ((*((struct_descripteur_fichier *)
5900: (*((struct_liste_chainee *)
5901: l_element_courant)).donnee)).type != 'C')
5902: {
5903: sqlite3_close((*((struct_descripteur_fichier *)
5904: (*((struct_liste_chainee *)
5905: l_element_courant)).donnee))
5906: .descripteur_sqlite);
5907: }
1.1 bertrand 5908:
5909: if ((*((struct_descripteur_fichier *)
5910: (*((struct_liste_chainee *)
5911: l_element_courant)).donnee))
5912: .effacement == 'Y')
5913: {
5914: unlink((*((struct_descripteur_fichier *)
5915: (*((struct_liste_chainee *)
5916: l_element_courant)).donnee))
5917: .nom);
5918: }
5919:
5920: free((*((struct_descripteur_fichier *)
5921: (*((struct_liste_chainee *)
5922: l_element_courant)).donnee)).nom);
5923: free((struct_descripteur_fichier *)
5924: (*((struct_liste_chainee *)
5925: l_element_courant)).donnee);
5926: free(l_element_courant);
5927:
5928: l_element_courant = l_element_suivant;
5929: }
5930:
5931: l_element_courant = (void *)
5932: (*s_etat_processus).s_sockets;
5933: while(l_element_courant != NULL)
5934: {
5935: l_element_suivant = (*((struct_liste_chainee *)
5936: l_element_courant)).suivant;
5937:
5938: if ((*((struct_socket *)
5939: (*(*((struct_liste_chainee *)
5940: l_element_courant)).donnee).objet))
5941: .socket_connectee == d_vrai)
5942: {
5943: shutdown((*((struct_socket *)
5944: (*(*((struct_liste_chainee *)
5945: l_element_courant)).donnee).objet))
5946: .socket, SHUT_RDWR);
5947: }
5948:
5949: close((*((struct_socket *)
5950: (*(*((struct_liste_chainee *)
5951: l_element_courant)).donnee).objet)).socket);
5952:
5953: if ((*((struct_socket *) (*(*((struct_liste_chainee *)
5954: l_element_courant)).donnee).objet)).effacement
5955: == 'Y')
5956: {
5957: unlink((*((struct_socket *)
5958: (*(*((struct_liste_chainee *)
5959: l_element_courant)).donnee).objet))
5960: .adresse);
5961: }
5962:
5963: liberation(s_etat_processus,
5964: (*((struct_liste_chainee *)
5965: l_element_courant)).donnee);
5966: free(l_element_courant);
5967:
5968: l_element_courant = l_element_suivant;
5969: }
5970:
5971: l_element_courant = (void *)
5972: (*s_etat_processus).s_connecteurs_sql;
5973: while(l_element_courant != NULL)
5974: {
5975: l_element_suivant = (*((struct_liste_chainee *)
5976: l_element_courant)).suivant;
5977:
5978: sqlclose((*((struct_liste_chainee *)
5979: l_element_courant)).donnee);
5980: liberation(s_etat_processus,
5981: (*((struct_liste_chainee *)
5982: l_element_courant)).donnee);
5983: free(l_element_courant);
5984:
5985: l_element_courant = l_element_suivant;
5986: }
5987:
5988: l_element_courant = (*s_etat_processus).s_marques;
5989: while(l_element_courant != NULL)
5990: {
5991: free((*((struct_marque *) l_element_courant)).label);
5992: free((*((struct_marque *) l_element_courant)).position);
5993: l_element_suivant = (*((struct_marque *)
5994: l_element_courant)).suivant;
5995: free(l_element_courant);
5996: l_element_courant = l_element_suivant;
5997: }
5998: }
5999: else
6000: {
6001: erreur = d_es_allocation_memoire;
6002:
6003: if (test_cfsf(s_etat_processus, 51) == d_faux)
6004: {
6005: printf("%s", ds_beep);
6006: }
6007:
6008: if ((*s_etat_processus).langue == 'F')
6009: {
6010: printf("+++Système : Mémoire insuffisante\n");
6011: }
6012: else
6013: {
6014: printf("+++System : Not enough memory\n");
6015: }
6016: }
6017: }
6018:
6019: liberation_allocateur(s_etat_processus);
6020: }
6021:
6022: if (traitement_fichier_temporaire == 'Y')
6023: {
1.124 ! bertrand 6024: destruction_fichier(nom_fichier_temporaire);
1.1 bertrand 6025: free(nom_fichier_temporaire);
6026: }
6027:
6028: if ((*s_etat_processus).profilage == d_vrai)
6029: {
6030: ecriture_profil(s_etat_processus);
6031: liberation_profil(s_etat_processus);
6032: }
6033: }
6034:
6035: closelog();
6036:
6037: pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
6038: pthread_mutex_destroy(&((*((*s_etat_processus).s_liste_variables_partagees))
6039: .mutex));
6040:
6041: retrait_thread(s_etat_processus);
6042:
6043: pthread_mutex_destroy(&((*s_etat_processus).mutex));
1.30 bertrand 6044: pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
1.117 bertrand 6045: pthread_mutex_destroy(&mutex_sections_critiques);
1.29 bertrand 6046:
1.91 bertrand 6047: # ifndef SEMAPHORES_NOMMES
1.93 bertrand 6048: sem_post(&((*s_etat_processus).semaphore_fork));
6049: sem_destroy(&((*s_etat_processus).semaphore_fork));
1.91 bertrand 6050: # else
6051: sem_post((*s_etat_processus).semaphore_fork);
1.92 bertrand 6052: sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
6053: SEM_FORK);
1.91 bertrand 6054: # endif
1.1 bertrand 6055:
6056: free((*s_etat_processus).localisation);
6057:
1.17 bertrand 6058: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 6059: sem_post(&semaphore_gestionnaires_signaux);
6060: sem_destroy(&semaphore_gestionnaires_signaux);
1.17 bertrand 6061: # else
6062: sem_post(semaphore_gestionnaires_signaux);
1.92 bertrand 6063: sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
1.17 bertrand 6064: # endif
1.1 bertrand 6065:
1.83 bertrand 6066: destruction_queue_signaux(s_etat_processus);
1.76 bertrand 6067: liberation_contexte_cas(s_etat_processus);
6068:
1.40 bertrand 6069: free((*s_etat_processus).chemin_fichiers_temporaires);
1.103 bertrand 6070:
6071: if ((*s_etat_processus).requete_redemarrage == d_vrai)
6072: {
6073: chdir(repertoire_initial);
1.105 bertrand 6074: execvp(arg_exec[0], &(arg_exec[0]));
1.103 bertrand 6075: erreur = d_erreur;
6076: }
6077:
1.104 bertrand 6078: free(arg_exec);
1.122 bertrand 6079: arret_thread_signaux(s_etat_processus);
1.24 bertrand 6080: free(s_etat_processus);
6081:
1.8 bertrand 6082: # ifdef DEBUG_MEMOIRE
1.24 bertrand 6083: debug_memoire_verification();
6084: analyse_post_mortem();
1.8 bertrand 6085: # endif
6086:
1.94 bertrand 6087: # ifdef HAVE_STACK_OVERFLOW_RECOVERY
6088: stackoverflow_deinstall_handler();
6089: # endif
6090:
6091: # ifdef HAVE_SIGSEGV_RECOVERY
6092: if (debug == d_faux)
6093: {
6094: sigsegv_deinstall_handler();
6095: }
6096: # endif
6097:
1.13 bertrand 6098: return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);
1.1 bertrand 6099: }
6100:
6101:
6102: void
6103: informations(struct_processus *s_etat_processus)
6104: {
6105: printf("\n");
6106:
6107: if ((*s_etat_processus).langue == 'F')
6108: {
6109: printf(" rpl [-options] [programme]\n");
1.13 bertrand 6110: printf(" -a : analyse du code\n");
1.1 bertrand 6111: printf(" -A : paramètres passés au programme principal\n");
6112: printf(" -c : génération de fichier de débogage (rpl-core)\n");
6113: printf(" -d : option de déverminage interne\n");
6114: printf(" -D : lancement d'un daemon\n");
6115: printf(" -h : aide sur la ligne de commande\n");
6116: printf(" -i : fonctionnement interactif\n");
6117: printf(" -l : licence d'utilisation\n");
6118: printf(" -n : ignorance du signal HUP\n");
6119: printf(" -p : précompilation du script avant exécution\n");
1.124 ! bertrand 6120: printf(" -P : profilage (-P ou -PP)\n");
1.1 bertrand 6121: printf(" -s : empêchement de l'ouverture de l'écran initial\n");
6122: printf(" -S : exécution du script passé en ligne de commande\n");
6123: printf(" -t : trace\n");
6124: printf(" -v : version\n");
6125: }
6126: else
6127: {
6128: printf(" rpl [-options] [program]\n");
1.13 bertrand 6129: printf(" -a : analyzes program\n");
1.1 bertrand 6130: printf(" -A : sends parameters to main program\n");
6131: printf(" -c : allows creation of a rpl-core file, providing a way"
6132: "\n"
6133: " to debug a program\n");
6134: printf(" -d : internal debug process\n");
6135: printf(" -D : starts in daemon mode\n");
6136: printf(" -h : shows a summary of available options\n");
6137: printf(" -i : runs the RPL/2 sequencer in interactive mode\n");
6138: printf(" -l : prints the user licence of the software\n");
6139: printf(" -n : ignores HUP signal\n");
6140: printf(" -p : precompiles script\n");
1.124 ! bertrand 6141: printf(" -P : computes profile data (-P or -PP)\n");
1.1 bertrand 6142: printf(" -s : disables splash screen\n");
6143: printf(" -S : executes script written in command line\n");
6144: printf(" -t : enables tracing mode\n");
6145: printf(" -v : prints the version number\n");
6146: }
6147:
6148: printf("\n");
6149:
6150: return;
6151: }
6152:
1.96 bertrand 6153:
1.100 bertrand 6154: logical1
6155: controle_integrite(struct_processus *s_etat_processus,
6156: unsigned char *executable_candidat, unsigned char *executable)
6157: {
6158: unsigned char *md5;
6159: unsigned char *sha1;
6160:
6161: if (strcmp(executable, "rplpp") == 0)
6162: {
6163: md5 = rplpp_md5;
6164: sha1 = rplpp_sha1;
6165: }
6166: else if (strcmp(executable, "rplfile") == 0)
6167: {
6168: md5 = rplfile_md5;
6169: sha1 = rplfile_sha1;
6170: }
6171: else if (strcmp(executable, "rpliconv") == 0)
6172: {
6173: md5 = rpliconv_md5;
6174: sha1 = rpliconv_sha1;
6175: }
6176: else if (strcmp(executable, "rplawk") == 0)
6177: {
6178: md5 = rplawk_md5;
6179: sha1 = rplawk_sha1;
6180: }
6181: else if (strcmp(executable, "rplconvert") == 0)
6182: {
6183: md5 = rplconvert_md5;
6184: sha1 = rplconvert_sha1;
6185: }
6186: else
6187: {
6188: return(d_faux);
6189: }
6190:
6191: if (controle(s_etat_processus, executable_candidat, "md5", md5) != d_vrai)
6192: {
6193: return(d_faux);
6194: }
6195:
6196: if (controle(s_etat_processus, executable_candidat, "sha1", sha1) != d_vrai)
6197: {
6198: return(d_faux);
6199: }
6200:
6201: return(d_vrai);
6202: }
6203:
6204:
1.96 bertrand 6205: unsigned char *
6206: date_compilation()
6207: {
6208: unsigned char *date;
6209:
6210: if ((date = malloc((strlen(d_date_en_rpl) + 1) * sizeof(unsigned char)))
6211: == NULL)
6212: {
6213: return(NULL);
6214: }
6215:
6216: strcpy(date, d_date_en_rpl);
6217:
6218: return(date);
6219: }
6220:
1.1 bertrand 6221: // vim: ts=4