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