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