File:
[local] /
rpl /
src /
rpl.c
Revision
1.23:
download - view:
text,
annotated -
select for diffs -
revision graph
Thu Apr 29 07:30:58 2010 UTC (14 years ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction d'un point bloquant dans la gestion des processus
(affectation des interruptions logicielles survenant après l'arrêt du
processus père car le mutex de protection de la routine était déjà positionné
dans la fonction appelante). Ajout de la fonction CLRATEXIT.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.15
4: Copyright (C) 1989-2010 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:
27: /*
28: ================================================================================
29: Programme principal
30: ================================================================================
31: */
32:
33: int
34: rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home)
35: {
36: # include "copyright.conv.h"
37: # include "licence.conv.h"
38:
39: file *f_source;
40:
41: int erreur_historique;
42: int option_P;
43: int status;
44:
45: logical1 core;
46: logical1 debug;
47: logical1 erreur_fichier;
48: logical1 existence;
49: logical1 mode_interactif;
50: logical1 option_a;
51: logical1 option_A;
52: logical1 option_c;
53: logical1 option_d;
54: logical1 option_D;
55: logical1 option_h;
56: logical1 option_i;
57: logical1 option_l;
58: logical1 option_n;
59: logical1 option_p;
60: logical1 option_s;
61: logical1 option_S;
62: logical1 option_t;
63: logical1 option_v;
64: logical1 ouverture;
65:
66: pthread_mutexattr_t attributs_mutex;
67:
68: ssize_t longueur_ecriture;
69:
70: struct_objet *s_objet;
71:
72: struct_processus *s_etat_processus;
73:
74: struct_table_variables_partagees s_variables_partagees;
75:
76: struct sigaction action;
77: struct sigaction registre;
78:
79: struct timespec attente;
80:
81: unsigned char *arguments;
82: unsigned char drapeau_encart;
83: unsigned char *type_debug;
84: unsigned char *home;
85: unsigned char *langue;
86: unsigned char *message;
87: unsigned char *nom_fichier_temporaire;
88: unsigned char option;
89: unsigned char presence_definition;
90: unsigned char *ptr;
91: unsigned char *tampon;
92:
93: unsigned long i;
94: unsigned long unite_fichier;
95:
96: void *l_element_courant;
97: void *l_element_suivant;
98:
99: volatile int erreur;
100: volatile unsigned char traitement_fichier_temporaire;
101:
102: setvbuf(stdout, NULL, _IOLBF, 0);
103: setvbuf(stderr, NULL, _IOLBF, 0);
104:
105: # ifndef SEMAPHORES_NOMMES
106: sem_init(&semaphore_liste_threads, 0, 1);
107: sem_init(&semaphore_gestionnaires_signaux, 0, 0);
108: sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
109: # else
110: semaphore_liste_threads = sem_init2(1, sem_liste_threads);
111: semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
112: semaphore_gestionnaires_signaux_atomique = sem_init2(1,
113: sem_gestionnaires_signaux_atomique);
114:
115: if ((semaphore_liste_threads == SEM_FAILED) ||
116: (semaphore_gestionnaires_signaux == SEM_FAILED) ||
117: (semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
118: {
119: erreur = d_es_allocation_memoire;
120:
121: if ((langue = getenv("LANG")) != NULL)
122: {
123: if (strncmp(langue, "fr", 2) == 0)
124: {
125: uprintf("+++Système : Mémoire insuffisante\n");
126: }
127: else
128: {
129: uprintf("+++System : Not enough memory\n");
130: }
131: }
132: else
133: {
134: uprintf("+++System : Not enough memory\n");
135: }
136:
137: return(EXIT_FAILURE);
138: }
139: # endif
140:
141: if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
142: {
143: erreur = d_es_allocation_memoire;
144:
145: if ((langue = getenv("LANG")) != NULL)
146: {
147: if (strncmp(langue, "fr", 2) == 0)
148: {
149: uprintf("+++Système : Mémoire insuffisante\n");
150: }
151: else
152: {
153: uprintf("+++System : Not enough memory\n");
154: }
155: }
156: else
157: {
158: uprintf("+++System : Not enough memory\n");
159: }
160:
161: return(EXIT_FAILURE);
162: }
163:
164: if ((langue = getenv("LANG")) != NULL)
165: {
166: (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
167: ? 'F' : 'E';
168: }
169: else
170: {
171: (*s_etat_processus).langue = 'E';
172: }
173:
174: (*s_etat_processus).exception = d_ep;
175: (*s_etat_processus).erreur_systeme = d_es;
176: (*s_etat_processus).erreur_execution = d_ex;
177:
178: (*s_etat_processus).rpl_home = rpl_home;
179:
180: insertion_thread(s_etat_processus, d_vrai);
181:
182: pthread_mutexattr_init(&attributs_mutex);
183: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
184: pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
185: pthread_mutexattr_destroy(&attributs_mutex);
186:
187: # ifndef SEMAPHORES_NOMMES
188: sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
189: # else
190: if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==
191: SEM_FAILED)
192: {
193: if ((*s_etat_processus).langue == 'F')
194: {
195: uprintf("+++Système : Mémoire insuffisante\n");
196: }
197: else
198: {
199: uprintf("+++System : Not enough memory\n");
200: }
201:
202: return(EXIT_FAILURE);
203: }
204: # endif
205:
206: pthread_mutexattr_init(&attributs_mutex);
207: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
208: pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes),
209: &attributs_mutex);
210: pthread_mutexattr_destroy(&attributs_mutex);
211:
212: (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees;
213:
214: s_variables_partagees.nombre_variables = 0;
215: s_variables_partagees.nombre_variables_allouees = 0;
216: s_variables_partagees.table = NULL;
217:
218: pthread_mutexattr_init(&attributs_mutex);
219: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
220: pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees))
221: .mutex), &attributs_mutex);
222: pthread_mutexattr_destroy(&attributs_mutex);
223:
224: localisation_courante(s_etat_processus);
225: (*s_etat_processus).erreur_systeme = d_es;
226:
227: if ((*s_etat_processus).localisation == NULL)
228: {
229: if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
230: sizeof(unsigned char))) == NULL)
231: {
232: if ((*s_etat_processus).langue == 'F')
233: {
234: uprintf("+++Système : Mémoire insuffisante\n");
235: }
236: else
237: {
238: uprintf("+++System : Not enough memory\n");
239: }
240:
241: return(EXIT_FAILURE);
242: }
243:
244: strcpy((*s_etat_processus).localisation, d_locale);
245: }
246:
247: printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
248: ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);
249:
250: if ((*s_etat_processus).langue == 'F')
251: {
252: printf("+++Copyright (C) 1989 à 2009, 2010 BERTRAND Joël\n");
253: }
254: else
255: {
256: printf("+++Copyright (C) 1989 to 2009, 2010 BERTRAND Joel\n");
257: }
258:
259: if (getenv("HOME") != NULL)
260: {
261: home = getenv("HOME");
262: }
263: else if ((getenv("USER") != NULL) && (getpwnam(getenv("USER")) != NULL))
264: {
265: home = getpwnam(getenv("USER"))->pw_dir;
266: }
267: else if ((getenv("LOGNAME") != NULL) && (getpwnam(getenv("LOGNAME"))
268: != NULL))
269: {
270: home = getpwnam(getenv("LOGNAME"))->pw_dir;
271: }
272: else if ((getuid() != ((uid_t) -1)) && (getpwuid(getuid()) != NULL))
273: {
274: home = getpwuid(getuid())->pw_dir;
275: }
276: else
277: {
278: home = "";
279: }
280:
281: // Initialisation d'une clef
282:
283: if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)
284: {
285: if ((*s_etat_processus).langue == 'F')
286: {
287: printf("+++Système : Mémoire insuffisante\n");
288: }
289: else
290: {
291: printf("+++System : Not enough memory\n");
292: }
293:
294: return(EXIT_FAILURE);
295: }
296:
297: # ifndef SEMAPHORES_NOMMES
298: if (pthread_setspecific(semaphore_fork_processus_courant,
299: &((*s_etat_processus).semaphore_fork)) != 0)
300: # else
301: if (pthread_setspecific(semaphore_fork_processus_courant,
302: (*s_etat_processus).semaphore_fork) != 0)
303: # endif
304: {
305: if ((*s_etat_processus).langue == 'F')
306: {
307: printf("+++Système : Mémoire insuffisante\n");
308: }
309: else
310: {
311: printf("+++System : Not enough memory\n");
312: }
313:
314: return(EXIT_FAILURE);
315: }
316:
317: // Initialisation d'une pile de signal pour récupérer les
318: // débordement de pile
319:
320: # ifndef Cygwin
321: if (((*s_etat_processus).pile_signal.ss_sp =
322: malloc((*s_etat_processus).pile_signal.ss_size =
323: SIGSTKSZ)) == NULL)
324: {
325: erreur = d_es_allocation_memoire;
326:
327: if ((*s_etat_processus).langue == 'F')
328: {
329: printf("+++Système : Mémoire insuffisante\n");
330: }
331: else
332: {
333: printf("+++System : Not enough memory\n");
334: }
335:
336: return(EXIT_FAILURE);
337: }
338:
339: (*s_etat_processus).pile_signal.ss_flags = 0;
340:
341: if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 0)
342: {
343: erreur = d_es_signal;
344:
345: if ((*s_etat_processus).langue == 'F')
346: {
347: printf("+++Système : Initialisation de la pile spécifique de signal"
348: " impossible\n");
349: }
350: else
351: {
352: printf("+++System : Initialization of signal stack failed\n");
353: }
354:
355: return(EXIT_FAILURE);
356: }
357: # endif
358:
359: action.sa_sigaction = interruption1;
360: action.sa_flags = SA_ONSTACK | SA_SIGINFO;
361:
362: if (sigaction(SIGINT, &action, NULL) != 0)
363: {
364: erreur = d_es_signal;
365:
366: if ((*s_etat_processus).langue == 'F')
367: {
368: printf("+++Système : Initialisation des signaux POSIX "
369: "impossible\n");
370: }
371: else
372: {
373: printf("+++System : Initialization of POSIX signals failed\n");
374: }
375:
376: return(EXIT_FAILURE);
377: }
378:
379: action.sa_sigaction = interruption2;
380: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
381:
382: if (sigaction(SIGTSTP, &action, NULL) != 0)
383: {
384: if ((*s_etat_processus).langue == 'F')
385: {
386: printf("+++Système : Initialisation des signaux POSIX "
387: "impossible\n");
388: }
389: else
390: {
391: printf("+++System : Initialization of POSIX signals failed\n");
392: }
393:
394: return(EXIT_FAILURE);
395: }
396:
397: action.sa_sigaction = interruption4;
398: action.sa_flags = SA_ONSTACK | SA_SIGINFO;
399:
400: if (sigaction(SIGSTART, &action, NULL) != 0)
401: {
402: if ((*s_etat_processus).langue == 'F')
403: {
404: printf("+++Système : Initialisation des signaux POSIX "
405: "impossible\n");
406: }
407: else
408: {
409: printf("+++System : Initialization of POSIX signals failed\n");
410: }
411:
412: return(EXIT_FAILURE);
413: }
414:
415: if (sigaction(SIGCONT, &action, NULL) != 0)
416: {
417: if ((*s_etat_processus).langue == 'F')
418: {
419: printf("+++Système : Initialisation des signaux POSIX "
420: "impossible\n");
421: }
422: else
423: {
424: printf("+++System : Initialization of POSIX signals failed\n");
425: }
426:
427: return(EXIT_FAILURE);
428: }
429:
430: action.sa_sigaction = interruption5;
431: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
432:
433: if (sigaction(SIGFSTOP, &action, NULL) != 0)
434: {
435: erreur = d_es_signal;
436:
437: if ((*s_etat_processus).langue == 'F')
438: {
439: printf("+++Système : Initialisation des signaux POSIX "
440: "impossible\n");
441: }
442: else
443: {
444: printf("+++System : Initialization of POSIX signals failed\n");
445: }
446:
447: return(EXIT_FAILURE);
448: }
449:
450: if (sigaction(SIGFABORT, &action, NULL) != 0)
451: {
452: erreur = d_es_signal;
453:
454: if ((*s_etat_processus).langue == 'F')
455: {
456: printf("+++Système : Initialisation des signaux POSIX "
457: "impossible\n");
458: }
459: else
460: {
461: printf("+++System : Initialization of POSIX signals failed\n");
462: }
463:
464: return(EXIT_FAILURE);
465: }
466:
467: action.sa_sigaction = interruption8;
468: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
469:
470: if (sigaction(SIGURG, &action, NULL) != 0)
471: {
472: erreur = d_es_signal;
473:
474: if ((*s_etat_processus).langue == 'F')
475: {
476: printf("+++Système : Initialisation des signaux POSIX "
477: "impossible\n");
478: }
479: else
480: {
481: printf("+++System : Initialization of POSIX signals failed\n");
482: }
483:
484: return(EXIT_FAILURE);
485: }
486:
487: action.sa_sigaction = interruption7;
488: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
489:
490: if (sigaction(SIGPIPE, &action, NULL) != 0)
491: {
492: erreur = d_es_signal;
493:
494: if ((*s_etat_processus).langue == 'F')
495: {
496: printf("+++Système : Initialisation des signaux POSIX "
497: "impossible\n");
498: }
499: else
500: {
501: printf("+++System : Initialization of POSIX signals failed\n");
502: }
503:
504: return(EXIT_FAILURE);
505: }
506:
507: action.sa_sigaction = interruption6;
508: action.sa_flags = SA_ONSTACK | SA_SIGINFO;
509:
510: if (sigaction(SIGINJECT, &action, NULL) != 0)
511: {
512: erreur = d_es_signal;
513:
514: if ((*s_etat_processus).langue == 'F')
515: {
516: printf("+++Système : Initialisation des signaux POSIX "
517: "impossible\n");
518: }
519: else
520: {
521: printf("+++System : Initialization of POSIX signals failed\n");
522: }
523:
524: return(EXIT_FAILURE);
525: }
526:
527: action.sa_sigaction = interruption9;
528: action.sa_flags = SA_ONSTACK | SA_SIGINFO;
529:
530: if (sigaction(SIGABORT, &action, NULL) != 0)
531: {
532: erreur = d_es_signal;
533:
534: if ((*s_etat_processus).langue == 'F')
535: {
536: printf("+++Système : Initialisation des signaux POSIX "
537: "impossible\n");
538: }
539: else
540: {
541: printf("+++System : Initialization of POSIX signals failed\n");
542: }
543:
544: return(EXIT_FAILURE);
545: }
546:
547: action.sa_sigaction = interruption1;
548: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
549:
550: if (sigaction(SIGALRM, &action, NULL) != 0)
551: {
552: erreur = d_es_signal;
553:
554: if ((*s_etat_processus).langue == 'F')
555: {
556: printf("+++Système : Initialisation des signaux POSIX "
557: "impossible\n");
558: }
559: else
560: {
561: printf("+++System : Initialization of POSIX signals failed\n");
562: }
563:
564: return(EXIT_FAILURE);
565: }
566:
567: action.sa_sigaction = interruption3;
568: action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
569:
570: (*s_etat_processus).chemin_fichiers_temporaires =
571: recherche_chemin_fichiers_temporaires(s_etat_processus);
572:
573: erreur = d_absence_erreur;
574: core = d_faux;
575: mode_interactif = d_faux;
576: (*s_etat_processus).nom_fichier_source = NULL;
577: (*s_etat_processus).definitions_chainees = NULL;
578: (*s_etat_processus).type_debug = 0;
579: traitement_fichier_temporaire = 'N';
580: option = ' ';
581: drapeau_encart = 'Y';
582: debug = d_faux;
583: arguments = NULL;
584:
585: (*s_etat_processus).s_fichiers = NULL;
586: (*s_etat_processus).s_sockets = NULL;
587: (*s_etat_processus).s_connecteurs_sql = NULL;
588:
589: setlogmask(LOG_MASK(LOG_NOTICE));
590: openlog(argv[0], LOG_ODELAY | LOG_PID, LOG_USER);
591:
592: if (argc == 1)
593: {
594: erreur = d_erreur;
595: informations(s_etat_processus);
596: }
597: else
598: {
599: presence_definition = 'N';
600: (*s_etat_processus).debug = d_faux;
601: (*s_etat_processus).lancement_interactif = d_faux;
602:
603: option_a = d_faux;
604: option_A = d_faux;
605: option_c = d_faux;
606: option_d = d_faux;
607: option_D = d_faux;
608: option_h = d_faux;
609: option_i = d_faux;
610: option_l = d_faux;
611: option_n = d_faux;
612: option_p = d_faux;
613: option_P = 0;
614: option_s = d_faux;
615: option_S = d_faux;
616: option_t = d_faux;
617: option_v = d_faux;
618:
619: while((--argc) > 0)
620: {
621: if ((*(++argv))[0] == '-')
622: {
623: while((option = *(++argv[0])) != '\0')
624: {
625: switch(option)
626: {
627: case 'a' :
628: {
629: if (option_a == d_vrai)
630: {
631: if ((*s_etat_processus).langue == 'F')
632: {
633: printf("+++Erreur : option -a présente "
634: "plus d'une fois\n");
635: }
636: else
637: {
638: printf("+++Error : more than one -a "
639: "on command line");
640: }
641:
642: return(EXIT_FAILURE);
643: }
644:
645: option_a = d_vrai;
646: break;
647: }
648:
649: case 'A' :
650: {
651: if (option_A == d_vrai)
652: {
653: if ((*s_etat_processus).langue == 'F')
654: {
655: printf("+++Erreur : option -A présente "
656: "plus d'une fois\n");
657: }
658: else
659: {
660: printf("+++Error : more than one -A "
661: "on command line");
662: }
663:
664: return(EXIT_FAILURE);
665: }
666:
667: option_A = d_vrai;
668:
669: while(*(++argv[0]) == ' ');
670: argv[0]--;
671:
672: if ((*(++argv[0])) != '\0')
673: {
674: if ((arguments = malloc((strlen(argv[0]) + 7) *
675: sizeof(unsigned char))) == NULL)
676: {
677: if ((*s_etat_processus).langue == 'F')
678: {
679: printf("+++Système : Mémoire "
680: "insuffisante\n");
681: }
682: else
683: {
684: printf("+++System : Not enough "
685: "memory\n");
686: }
687:
688: return(EXIT_FAILURE);
689: }
690:
691: ptr = arguments;
692: (*ptr) = d_code_fin_chaine;
693: strcat(ptr, "<< ");
694: ptr += 3;
695:
696: while(*(argv[0]) != '\0')
697: {
698: *(ptr++) = *(argv[0]++);
699: }
700:
701: (*ptr) = '\0';
702:
703: strcat(arguments, " >>");
704: argv[0]--;
705: }
706: else if ((--argc) > 0)
707: {
708: argv++;
709:
710: if ((arguments = malloc((strlen(argv[0]) + 7) *
711: sizeof(unsigned char))) == NULL)
712: {
713: if ((*s_etat_processus).langue == 'F')
714: {
715: printf("+++Système : Mémoire "
716: "insuffisante\n");
717: }
718: else
719: {
720: printf("+++System : Not enough "
721: "memory\n");
722: }
723:
724: return(EXIT_FAILURE);
725: }
726:
727: ptr = arguments;
728: (*ptr) = d_code_fin_chaine;
729: strcat(ptr, "<< ");
730: ptr += 3;
731:
732: while(*(argv[0]) != '\0')
733: {
734: *(ptr++) = *(argv[0]++);
735: }
736:
737: (*ptr) = '\0';
738:
739: strcat(arguments, " >>");
740: argv[0]--;
741: }
742: else
743: {
744: if ((*s_etat_processus).langue == 'F')
745: {
746: printf("+++Erreur : Aucune donnée "
747: "spécifié après l'option -A\n");
748: }
749: else
750: {
751: printf("+++Error : Data required after "
752: "-A option\n");
753: }
754:
755: return(EXIT_FAILURE);
756: }
757:
758: break;
759: }
760:
761: case 'c' :
762: {
763: if (option_c == d_vrai)
764: {
765: if ((*s_etat_processus).langue == 'F')
766: {
767: printf("+++Erreur : option -c présente "
768: "plus d'une fois\n");
769: }
770: else
771: {
772: printf("+++Error : more than one -c "
773: "on command line");
774: }
775:
776: return(EXIT_FAILURE);
777: }
778:
779: option_c = d_vrai;
780: core = d_vrai;
781: break;
782: }
783:
784: case 'd' :
785: {
786: if (option_d == d_vrai)
787: {
788: if ((*s_etat_processus).langue == 'F')
789: {
790: printf("+++Erreur : option -d présente "
791: "plus d'une fois\n");
792: }
793: else
794: {
795: printf("+++Error : more than one -d "
796: "on command line");
797: }
798:
799: return(EXIT_FAILURE);
800: }
801:
802: option_d = d_vrai;
803: debug = d_vrai;
804: break;
805: }
806:
807: case 'D' :
808: {
809: if (option_D == d_vrai)
810: {
811: if ((*s_etat_processus).langue == 'F')
812: {
813: printf("+++Erreur : option -D présente "
814: "plus d'une fois\n");
815: }
816: else
817: {
818: printf("+++Error : more than one -D "
819: "on command line");
820: }
821:
822: return(EXIT_FAILURE);
823: }
824:
825: option_D = d_vrai;
826: break;
827: }
828:
829: case 'h' :
830: {
831: if (option_h == d_vrai)
832: {
833: if ((*s_etat_processus).langue == 'F')
834: {
835: printf("+++Erreur : option -h présente "
836: "plus d'une fois\n");
837: }
838: else
839: {
840: printf("+++Error : more than one -h "
841: "on command line");
842: }
843:
844: return(EXIT_FAILURE);
845: }
846:
847: option_h = d_vrai;
848: informations(s_etat_processus);
849: break;
850: }
851:
852: case 'i' :
853: {
854: if (option_i == d_vrai)
855: {
856: if ((*s_etat_processus).langue == 'F')
857: {
858: printf("+++Erreur : option -i présente "
859: "plus d'une fois\n");
860: }
861: else
862: {
863: printf("+++Error : more than one -i "
864: "on command line");
865: }
866:
867: return(EXIT_FAILURE);
868: }
869: else if (option_S == d_vrai)
870: {
871: if ((*s_etat_processus).langue == 'F')
872: {
873: printf("+++Erreur : options -i et -S "
874: "incompatibles\n");
875: }
876: else
877: {
878: printf("+++Error : incompatible options -i "
879: "and -S\n");
880: }
881:
882: return(EXIT_FAILURE);
883: }
884: else if (option_p == d_vrai)
885: {
886: if ((*s_etat_processus).langue == 'F')
887: {
888: printf("+++Erreur : options -i et -p "
889: "incompatibles\n");
890: }
891: else
892: {
893: printf("+++Error : incompatible options -i "
894: "and -p\n");
895: }
896:
897: return(EXIT_FAILURE);
898: }
899:
900: option_i = d_vrai;
901: mode_interactif = d_vrai;
902: presence_definition = 'O';
903: break;
904: }
905:
906: case 'l' :
907: {
908: if (option_l == d_vrai)
909: {
910: if ((*s_etat_processus).langue == 'F')
911: {
912: printf("+++Erreur : option -l présente "
913: "plus d'une fois\n");
914: }
915: else
916: {
917: printf("+++Error : more than one -l "
918: "on command line");
919: }
920:
921: return(EXIT_FAILURE);
922: }
923:
924: option_l = d_vrai;
925:
926: if ((*s_etat_processus).langue == 'F')
927: {
928: printf("%s\n\n", CeCILL_fr);
929: }
930: else
931: {
932: printf("%s\n\n", CeCILL_en);
933: }
934:
935: break;
936: }
937:
938: case 'n' :
939: {
940: if (option_n == d_vrai)
941: {
942: if ((*s_etat_processus).langue == 'F')
943: {
944: printf("+++Erreur : option -n présente "
945: "plus d'une fois\n");
946: }
947: else
948: {
949: printf("+++Error : more than one -n "
950: "on command line");
951: }
952:
953: return(EXIT_FAILURE);
954: }
955:
956: option_n = d_vrai;
957:
958: break;
959: }
960:
961: case 'p' :
962: {
963: if (option_p == d_vrai)
964: {
965: if ((*s_etat_processus).langue == 'F')
966: {
967: printf("+++Erreur : option -p présente "
968: "plus d'une fois\n");
969: }
970: else
971: {
972: printf("+++Error : more than one -p "
973: "on command line");
974: }
975:
976: return(EXIT_FAILURE);
977: }
978: else if (option_i == d_vrai)
979: {
980: if ((*s_etat_processus).langue == 'F')
981: {
982: printf("+++Erreur : options -i et -p "
983: "incompatibles\n");
984: }
985: else
986: {
987: printf("+++Error : incompatible options -i "
988: "and -p\n");
989: }
990:
991: return(EXIT_FAILURE);
992: }
993:
994: option_p = d_vrai;
995:
996: break;
997: }
998:
999: case 'P' :
1000: {
1001: if (option_P > 2)
1002: {
1003: if ((*s_etat_processus).langue == 'F')
1004: {
1005: printf("+++Erreur : option -P présente "
1006: "plus de deux fois\n");
1007: }
1008: else
1009: {
1010: printf("+++Error : more than two -P "
1011: "on command line");
1012: }
1013:
1014: return(EXIT_FAILURE);
1015: }
1016:
1017: option_P++;
1018:
1019: break;
1020: }
1021:
1022: case 's' :
1023: {
1024: if (option_s == d_vrai)
1025: {
1026: if ((*s_etat_processus).langue == 'F')
1027: {
1028: printf("+++Erreur : option -s présente "
1029: "plus d'une fois\n");
1030: }
1031: else
1032: {
1033: printf("+++Error : more than one -s "
1034: "on command line");
1035: }
1036:
1037: return(EXIT_FAILURE);
1038: }
1039:
1040: option_s = d_vrai;
1041: drapeau_encart = 'N';
1042: break;
1043: }
1044:
1045: case 'S' :
1046: {
1047: if (option_S == d_vrai)
1048: {
1049: if ((*s_etat_processus).langue == 'F')
1050: {
1051: printf("+++Erreur : option -S présente "
1052: "plus d'une fois\n");
1053: }
1054: else
1055: {
1056: printf("+++Error : more than one -S "
1057: "on command line");
1058: }
1059:
1060: return(EXIT_FAILURE);
1061: }
1062: else if (option_i == d_vrai)
1063: {
1064: if ((*s_etat_processus).langue == 'F')
1065: {
1066: printf("+++Erreur : options -i et -S "
1067: "incompatibles\n");
1068: }
1069: else
1070: {
1071: printf("+++Error : incompatible options -S "
1072: "and -i\n");
1073: }
1074:
1075: return(EXIT_FAILURE);
1076: }
1077:
1078: option_S = d_vrai;
1079:
1080: while(*(++argv[0]) == ' ');
1081: argv[0]--;
1082:
1083: if ((*(++argv[0])) != '\0')
1084: {
1085: if (((*s_etat_processus).definitions_chainees =
1086: malloc((strlen(argv[0]) + 1) *
1087: sizeof(unsigned char))) == NULL)
1088: {
1089: if ((*s_etat_processus).langue == 'F')
1090: {
1091: printf("+++Système : Mémoire "
1092: "insuffisante\n");
1093: }
1094: else
1095: {
1096: printf("+++System : Not enough "
1097: "memory\n");
1098: }
1099:
1100: return(EXIT_FAILURE);
1101: }
1102:
1103: ptr = (*s_etat_processus).definitions_chainees;
1104:
1105: while(*(argv[0]) != '\0')
1106: {
1107: *(ptr++) = *(argv[0]++);
1108: }
1109:
1110: (*ptr) = '\0';
1111:
1112: argv[0]--;
1113: presence_definition = 'O';
1114: }
1115: else if ((--argc) > 0)
1116: {
1117: argv++;
1118:
1119: if (((*s_etat_processus).definitions_chainees =
1120: malloc((strlen(argv[0]) + 1) *
1121: sizeof(unsigned char))) == NULL)
1122: {
1123: if ((*s_etat_processus).langue == 'F')
1124: {
1125: printf("+++Système : Mémoire "
1126: "insuffisante\n");
1127: }
1128: else
1129: {
1130: printf("+++System : Not enough "
1131: "memory\n");
1132: }
1133:
1134: return(EXIT_FAILURE);
1135: }
1136:
1137: ptr = (*s_etat_processus).definitions_chainees;
1138:
1139: while(*(argv[0]) != '\0')
1140: {
1141: *(ptr++) = *(argv[0]++);
1142: }
1143:
1144: (*ptr) = '\0';
1145:
1146: argv[0]--;
1147: presence_definition = 'O';
1148: }
1149: else
1150: {
1151: if ((*s_etat_processus).langue == 'F')
1152: {
1153: printf("+++Erreur : Aucun script "
1154: "spécifié après l'option -S\n");
1155: }
1156: else
1157: {
1158: printf("+++Error : Script required after "
1159: "-S option\n");
1160: }
1161:
1162: return(EXIT_FAILURE);
1163: }
1164:
1165: if (((*s_etat_processus).definitions_chainees =
1166: compactage((*s_etat_processus)
1167: .definitions_chainees)) == NULL)
1168: {
1169: if ((*s_etat_processus).langue == 'F')
1170: {
1171: printf("+++Système : Mémoire "
1172: "insuffisante\n");
1173: }
1174: else
1175: {
1176: printf("+++System : Not enough "
1177: "memory\n");
1178: }
1179:
1180: return(EXIT_FAILURE);
1181: }
1182:
1183: (*s_etat_processus).longueur_definitions_chainees =
1184: strlen((*s_etat_processus)
1185: .definitions_chainees);
1186:
1187: break;
1188: }
1189:
1190: case 't' :
1191: {
1192: if (option_t == d_vrai)
1193: {
1194: if ((*s_etat_processus).langue == 'F')
1195: {
1196: printf("+++Erreur : option -t présente "
1197: "plus d'une fois\n");
1198: }
1199: else
1200: {
1201: printf("+++Error : more than one -t "
1202: "on command line");
1203: }
1204:
1205: return(EXIT_FAILURE);
1206: }
1207:
1208: option_t = d_vrai;
1209: (*s_etat_processus).debug = d_vrai;
1210:
1211: while(*(++argv[0]) == ' ');
1212: argv[0]--;
1213:
1214: if ((*(++argv[0])) != '\0')
1215: {
1216: if ((type_debug = malloc((strlen(argv[0]) + 1) *
1217: sizeof(unsigned char))) == NULL)
1218: {
1219: if ((*s_etat_processus).langue == 'F')
1220: {
1221: printf("+++Système : Mémoire "
1222: "insuffisante\n");
1223: }
1224: else
1225: {
1226: printf("+++System : Not enough "
1227: "memory\n");
1228: }
1229:
1230: return(EXIT_FAILURE);
1231: }
1232:
1233: ptr = type_debug;
1234:
1235: while((*(argv[0]) != '\0') &&
1236: (*(argv[0]) != ' '))
1237: {
1238: *(ptr++) = *(argv[0]++);
1239: }
1240:
1241: (*ptr) = '\0';
1242:
1243: argv[0]--;
1244: }
1245: else if ((--argc) > 0)
1246: {
1247: argv++;
1248:
1249: if ((type_debug =
1250: malloc((strlen(argv[0]) + 1) *
1251: sizeof(unsigned char))) == NULL)
1252: {
1253: if ((*s_etat_processus).langue == 'F')
1254: {
1255: printf("+++Système : Mémoire "
1256: "insuffisante\n");
1257: }
1258: else
1259: {
1260: printf("+++System : Not enough "
1261: "memory\n");
1262: }
1263:
1264: return(EXIT_FAILURE);
1265: }
1266:
1267: ptr = type_debug;
1268:
1269: while(*(argv[0]) != '\0')
1270: {
1271: *(ptr++) = *(argv[0]++);
1272: }
1273:
1274: (*ptr) = '\0';
1275:
1276: argv[0]--;
1277: }
1278: else
1279: {
1280: if ((*s_etat_processus).langue == 'F')
1281: {
1282: printf("+++Erreur : Aucun niveau "
1283: "de débogage spécifié après "
1284: "l'option -t\n");
1285: }
1286: else
1287: {
1288: printf("+++Error : Debug level not "
1289: "specified after -t option\n");
1290: }
1291:
1292: return(EXIT_FAILURE);
1293: }
1294:
1295: ptr = type_debug;
1296:
1297: while(*ptr != '\0')
1298: {
1299: switch(*ptr)
1300: {
1301: case '0':
1302: case '1':
1303: case '2':
1304: case '3':
1305: case '4':
1306: case '5':
1307: case '6':
1308: case '7':
1309: case '8':
1310: case '9':
1311: case 'A':
1312: case 'B':
1313: case 'C':
1314: case 'D':
1315: case 'E':
1316: case 'F':
1317: {
1318: break;
1319: }
1320:
1321: default:
1322: {
1323: if ((*s_etat_processus).langue == 'F')
1324: {
1325: printf("+++Erreur : Niveau "
1326: "de débogage non "
1327: "hexadécimal\n");
1328: }
1329: else
1330: {
1331: printf("+++Error : Debug level must"
1332: " be hexadecimal "
1333: "integer\n");
1334: }
1335:
1336: return(EXIT_FAILURE);
1337: }
1338: }
1339:
1340: ptr++;
1341: }
1342:
1343: if (sscanf(type_debug, "%llX",
1344: &((*s_etat_processus).type_debug)) != 1)
1345: {
1346: if ((*s_etat_processus).langue == 'F')
1347: {
1348: printf("+++Erreur : Niveau "
1349: "de débogage non entier\n");
1350: }
1351: else
1352: {
1353: printf("+++Error : Debug level must"
1354: " be integer\n");
1355: }
1356:
1357: return(EXIT_FAILURE);
1358: }
1359:
1360: free(type_debug);
1361: break;
1362: }
1363:
1364: case 'v' :
1365: {
1366: if (option_v == d_vrai)
1367: {
1368: if ((*s_etat_processus).langue == 'F')
1369: {
1370: printf("+++Erreur : option -v présente "
1371: "plus d'une fois\n");
1372: }
1373: else
1374: {
1375: printf("+++Error : more than one -v "
1376: "on command line");
1377: }
1378:
1379: return(EXIT_FAILURE);
1380: }
1381:
1382: option_v = d_vrai;
1383: printf("\n");
1384:
1385: if ((*s_etat_processus).langue == 'F')
1386: {
1387: printf(" Reverse Polish Lisp/2 version %s "
1388: "pour systèmes "
1389: "POSIX\n", d_version_rpl);
1390: printf(" Langage procédural de très haut "
1391: "niveau, semi-compilé, "
1392: "extensible,\n");
1393: printf(" destiné principalement aux "
1394: "calculs scientifiques et "
1395: "symboliques\n");
1396: printf("%s\n", copyright);
1397: }
1398: else
1399: {
1400: printf(" Reverse Polish Lisp/2 version %s "
1401: "for POSIX operating systems\n",
1402: d_version_rpl);
1403: printf(" Half-compiled, high-level "
1404: "procedural language,\n");
1405: printf(" mainly aiming at scientific "
1406: "calculations\n");
1407: printf("%s\n", copyright_anglais);
1408: }
1409:
1410: printf("\n");
1411: break;
1412: }
1413:
1414: default :
1415: {
1416: if ((*s_etat_processus).langue == 'F')
1417: {
1418: printf("+++Information : Option -%c inconnue\n",
1419: option);
1420: }
1421: else
1422: {
1423: printf("+++Warning : -%c option unknown\n",
1424: option);
1425: }
1426:
1427: informations(s_etat_processus);
1428: break;
1429: }
1430: }
1431: }
1432: }
1433: else
1434: {
1435: if (presence_definition == 'O')
1436: {
1437: argc = 0;
1438:
1439: if ((*s_etat_processus).langue == 'F')
1440: {
1441: printf("+++Erreur : Plusieurs définitions\n");
1442: }
1443: else
1444: {
1445: printf("+++Error : More than one definition\n");
1446: }
1447:
1448: erreur = d_erreur;
1449: }
1450: else
1451: {
1452: (*s_etat_processus).nom_fichier_source = argv[0];
1453: presence_definition = 'O';
1454: }
1455: }
1456: }
1457:
1458: if (debug == d_faux)
1459: {
1460: if (sigaction(SIGSEGV, &action, NULL) != 0)
1461: {
1462: if ((*s_etat_processus).langue == 'F')
1463: {
1464: printf("+++Système : Initialisation des signaux POSIX "
1465: "impossible\n");
1466: }
1467: else
1468: {
1469: printf("+++System : Initialization of POSIX signals "
1470: "failed\n");
1471: }
1472:
1473: return(EXIT_FAILURE);
1474: }
1475:
1476: if (sigaction(SIGBUS, &action, NULL) != 0)
1477: {
1478: if ((*s_etat_processus).langue == 'F')
1479: {
1480: printf("+++Système : Initialisation des signaux POSIX "
1481: "impossible\n");
1482: }
1483: else
1484: {
1485: printf("+++System : Initialization of POSIX signals "
1486: "failed\n");
1487: }
1488:
1489: return(EXIT_FAILURE);
1490: }
1491: }
1492:
1493: if (option_n == d_vrai)
1494: {
1495: action.sa_sigaction = interruption10;
1496: action.sa_flags = SA_ONSTACK | SA_SIGINFO;
1497:
1498: if (sigaction(SIGHUP, &action, NULL) != 0)
1499: {
1500: if ((*s_etat_processus).langue == 'F')
1501: {
1502: printf("+++Système : Initialisation des signaux POSIX "
1503: "impossible\n");
1504: }
1505: else
1506: {
1507: printf("+++System : Initialization of POSIX signals "
1508: "failed\n");
1509: }
1510:
1511: return(EXIT_FAILURE);
1512: }
1513: }
1514:
1515: if (mode_interactif == d_vrai)
1516: {
1517: printf("\n");
1518:
1519: if ((*s_etat_processus).langue == 'F')
1520: {
1521: printf("+++Ce logiciel est un logiciel libre"
1522: " sans aucune garantie de "
1523: "fonctionnement.\n");
1524: printf("+++Pour plus de détails, utilisez la "
1525: "commande 'warranty'.\n");
1526: }
1527: else
1528: {
1529: printf("+++This is a free software with "
1530: "absolutely no warranty.\n");
1531: printf("+++For details, type 'warranty'.\n");
1532: }
1533:
1534: printf("\n");
1535:
1536: traitement_fichier_temporaire = 'Y';
1537:
1538: if ((nom_fichier_temporaire =
1539: creation_nom_fichier(s_etat_processus, (*s_etat_processus)
1540: .chemin_fichiers_temporaires)) == NULL)
1541: {
1542: if ((*s_etat_processus).langue == 'F')
1543: {
1544: printf("+++Système : Fichier indisponible\n");
1545: }
1546: else
1547: {
1548: printf("+++System : File unavailable\n");
1549: }
1550:
1551: return(EXIT_FAILURE);
1552: }
1553:
1554: if ((f_source = fopen(nom_fichier_temporaire, "w"))
1555: == NULL)
1556: {
1557: if ((*s_etat_processus).langue == 'F')
1558: {
1559: printf("+++Système : Fichier introuvable\n");
1560: }
1561: else
1562: {
1563: printf("+++System : File not found\n");
1564: }
1565:
1566: return(EXIT_FAILURE);
1567: }
1568:
1569: if (fprintf(f_source, "MODE_INTERACTIF\n") < 0)
1570: {
1571: if ((*s_etat_processus).langue == 'F')
1572: {
1573: printf("+++Système : Erreur d'écriture dans un fichier\n");
1574: }
1575: else
1576: {
1577: printf("+++System : Cannot write in file\n");
1578: }
1579:
1580: return(EXIT_FAILURE);
1581: }
1582:
1583: if (fprintf(f_source,
1584: "<< DO HALT UNTIL FALSE END >>\n") < 0)
1585: {
1586: if ((*s_etat_processus).langue == 'F')
1587: {
1588: printf("+++Système : Erreur d'écriture dans un fichier\n");
1589: }
1590: else
1591: {
1592: printf("+++System : Cannot write in file\n");
1593: }
1594:
1595: return(EXIT_FAILURE);
1596: }
1597:
1598: if (fclose(f_source) != 0)
1599: {
1600: if ((*s_etat_processus).langue == 'F')
1601: {
1602: printf("+++Système : Fichier indisponible\n");
1603: }
1604: else
1605: {
1606: printf("+++System : File unavailable\n");
1607: }
1608:
1609: return(EXIT_FAILURE);
1610: }
1611:
1612: (*s_etat_processus).lancement_interactif = d_vrai;
1613: (*s_etat_processus).nom_fichier_source =
1614: nom_fichier_temporaire;
1615:
1616: presence_definition = 'O';
1617: }
1618: else
1619: {
1620: nom_fichier_temporaire = NULL;
1621: }
1622:
1623: if ((*s_etat_processus).nom_fichier_source == NULL)
1624: {
1625: erreur_fichier = d_erreur;
1626: }
1627: else
1628: {
1629: erreur_fichier = caracteristiques_fichier(s_etat_processus,
1630: (*s_etat_processus).nom_fichier_source,
1631: &existence, &ouverture, &unite_fichier);
1632: }
1633:
1634: if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) &&
1635: (option_S == d_faux))
1636: {
1637: if (presence_definition == 'O')
1638: {
1639: if ((*s_etat_processus).langue == 'F')
1640: {
1641: printf("+++Erreur : Fichier %s inexistant\n",
1642: (*s_etat_processus).nom_fichier_source);
1643: }
1644: else
1645: {
1646: printf("+++Error : File %s not found\n",
1647: (*s_etat_processus).nom_fichier_source);
1648: }
1649:
1650: erreur = d_erreur;
1651: }
1652: else
1653: {
1654: if ((*s_etat_processus).langue == 'F')
1655: {
1656: printf("+++Erreur : Absence de définition à exécuter\n");
1657: }
1658: else
1659: {
1660: printf("+++Error : Any executable definition\n");
1661: }
1662: }
1663:
1664: return(EXIT_FAILURE);
1665: }
1666:
1667: if ((*s_etat_processus).chemin_fichiers_temporaires == NULL)
1668: {
1669: if ((*s_etat_processus).langue == 'F')
1670: {
1671: printf("+++Système : Chemin des fichiers temporaires nul\n");
1672: }
1673: else
1674: {
1675: printf("+++System : Null temporary files path\n");
1676: }
1677:
1678: return(EXIT_FAILURE);
1679: }
1680:
1681: if ((*s_etat_processus).debug == d_vrai)
1682: {
1683: if ((*s_etat_processus).langue == 'F')
1684: {
1685: printf("[%d] Chemin des fichiers temporaires %s\n\n",
1686: (int) getpid(),
1687: (*s_etat_processus).chemin_fichiers_temporaires);
1688: }
1689: else
1690: {
1691: printf("[%d] Temporary files path %s\n\n",
1692: (int) getpid(),
1693: (*s_etat_processus).chemin_fichiers_temporaires);
1694: }
1695: }
1696:
1697: if ((erreur == d_absence_erreur) && (presence_definition == 'O'))
1698: {
1699: (*s_etat_processus).profilage = (option_P != 0) ? d_vrai : d_faux;
1700: (*s_etat_processus).niveau_profilage = option_P;
1701: (*s_etat_processus).pile_profilage = NULL;
1702: (*s_etat_processus).pile_profilage_fonctions = NULL;
1703: gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);
1704:
1705: (*s_etat_processus).liste_mutexes = NULL;
1706:
1707: (*s_etat_processus).test_instruction = 'N';
1708: (*s_etat_processus).nombre_arguments = 0;
1709: (*s_etat_processus).affichage_arguments = 'N';
1710: (*s_etat_processus).autorisation_conversion_chaine = 'Y';
1711: (*s_etat_processus).autorisation_evaluation_nom = 'Y';
1712: (*s_etat_processus).autorisation_nom_implicite = 'Y';
1713: (*s_etat_processus).autorisation_empilement_programme = 'N';
1714: (*s_etat_processus).requete_arret = 'N';
1715: (*s_etat_processus).evaluation_forcee = 'N';
1716:
1717: (*s_etat_processus).constante_symbolique = 'N';
1718: (*s_etat_processus).traitement_symbolique = 'N';
1719:
1720: (*s_etat_processus).expression_courante = NULL;
1721: (*s_etat_processus).objet_courant = NULL;
1722: (*s_etat_processus).evaluation_expression_compilee = 'N';
1723:
1724: (*s_etat_processus).l_base_pile = NULL;
1725: (*s_etat_processus).l_base_pile_last = NULL;
1726:
1727: (*s_etat_processus).s_liste_variables = NULL;
1728: (*s_etat_processus).gel_liste_variables = d_faux;
1729: (*s_etat_processus).nombre_variables = 0;
1730: (*s_etat_processus).nombre_variables_allouees = 0;
1731: (*s_etat_processus).s_liste_variables_statiques = NULL;
1732: (*s_etat_processus).nombre_variables_statiques = 0;
1733: (*s_etat_processus).nombre_variables_statiques_allouees = 0;
1734: (*s_etat_processus).niveau_courant = 0;
1735: (*s_etat_processus).niveau_initial = 0;
1736: (*s_etat_processus).creation_variables_statiques = d_faux;
1737: (*s_etat_processus).creation_variables_partagees = d_faux;
1738: (*s_etat_processus).position_variable_courante = 0;
1739: (*s_etat_processus).position_variable_statique_courante = 0;
1740:
1741: (*s_etat_processus).s_bibliotheques = NULL;
1742: (*s_etat_processus).s_instructions_externes = NULL;
1743: (*s_etat_processus).nombre_instructions_externes = 0;
1744:
1745: (*s_etat_processus).systeme_axes = 0;
1746:
1747: (*s_etat_processus).x_min = -10.;
1748: (*s_etat_processus).x_max = 10.;
1749: (*s_etat_processus).y_min = -10.;
1750: (*s_etat_processus).y_max = 10.;
1751: (*s_etat_processus).z_min = -10.;
1752: (*s_etat_processus).z_max = 10.;
1753:
1754: (*s_etat_processus).x2_min = -10.;
1755: (*s_etat_processus).x2_max = 10.;
1756: (*s_etat_processus).y2_min = -10.;
1757: (*s_etat_processus).y2_max = 10.;
1758: (*s_etat_processus).z2_min = -10.;
1759: (*s_etat_processus).z2_max = 10.;
1760:
1761: (*s_etat_processus).resolution = .01;
1762:
1763: (*s_etat_processus).souris_active = d_faux;
1764:
1765: (*s_etat_processus).echelle_automatique_x = d_faux;
1766: (*s_etat_processus).echelle_automatique_y = d_faux;
1767: (*s_etat_processus).echelle_automatique_z = d_faux;
1768:
1769: (*s_etat_processus).echelle_automatique_x2 = d_faux;
1770: (*s_etat_processus).echelle_automatique_y2 = d_faux;
1771: (*s_etat_processus).echelle_automatique_z2 = d_faux;
1772:
1773: (*s_etat_processus).echelle_log_x = d_faux;
1774: (*s_etat_processus).echelle_log_y = d_faux;
1775: (*s_etat_processus).echelle_log_z = d_faux;
1776:
1777: (*s_etat_processus).echelle_log_x2 = d_faux;
1778: (*s_etat_processus).echelle_log_y2 = d_faux;
1779: (*s_etat_processus).echelle_log_z2 = d_faux;
1780:
1781: (*s_etat_processus).point_de_vue_theta = 4 * atan((real8) 1) / 6;
1782: (*s_etat_processus).point_de_vue_phi = 4 * atan((real8) 1) / 3;
1783: (*s_etat_processus).echelle_3D = 1;
1784:
1785: strcpy((*s_etat_processus).type_trace_eq, "FONCTION");
1786: strcpy((*s_etat_processus).type_trace_sigma, "POINTS");
1787: (*s_etat_processus).fichiers_graphiques = NULL;
1788: (*s_etat_processus).nom_fichier_impression = NULL;
1789: strcpy((*s_etat_processus).format_papier, "a4paper");
1790: (*s_etat_processus).entree_standard = NULL;
1791: (*s_etat_processus).s_marques = NULL;
1792: (*s_etat_processus).requete_nouveau_plan = d_vrai;
1793: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
1794:
1795: (*s_etat_processus).l_base_pile = NULL;
1796: (*s_etat_processus).hauteur_pile_operationnelle = 0;
1797: (*s_etat_processus).l_base_pile_contextes = NULL;
1798: (*s_etat_processus).l_base_pile_taille_contextes = NULL;
1799:
1800: (*s_etat_processus).position_courante = 0;
1801:
1802: (*s_etat_processus).l_base_pile_systeme = NULL;
1803: (*s_etat_processus).hauteur_pile_systeme = 0;
1804:
1805: (*s_etat_processus).l_base_pile_processus = NULL;
1806: (*s_etat_processus).presence_pipes = d_faux;
1807: (*s_etat_processus).pipe_donnees = 0;
1808: (*s_etat_processus).pipe_acquittement = 0;
1809: (*s_etat_processus).pipe_injections = 0;
1810: (*s_etat_processus).pipe_nombre_injections = 0;
1811: (*s_etat_processus).nombre_objets_injectes = 0;
1812: (*s_etat_processus).nombre_objets_envoyes_non_lus = 0;
1813: (*s_etat_processus).pourcentage_maximal_cpu = 100;
1814: (*s_etat_processus).temps_maximal_cpu = 0;
1815: (*s_etat_processus).thread_fusible = 0;
1816: (*s_etat_processus).presence_fusible = d_faux;
1817:
1818: (*s_etat_processus).niveau_recursivite = 0;
1819: (*s_etat_processus).generateur_aleatoire = NULL;
1820: (*s_etat_processus).type_generateur_aleatoire = NULL;
1821:
1822: (*s_etat_processus).colonne_statistique_1 = 1;
1823: (*s_etat_processus).colonne_statistique_2 = 2;
1824:
1825: (*s_etat_processus).debug_programme = d_faux;
1826: (*s_etat_processus).execution_pas_suivant = d_faux;
1827: (*s_etat_processus).traitement_instruction_halt = d_faux;
1828:
1829: (*s_etat_processus).derniere_exception = d_ep;
1830: (*s_etat_processus).derniere_erreur_systeme = d_es;
1831: (*s_etat_processus).derniere_erreur_execution = d_ex;
1832: (*s_etat_processus).derniere_erreur_evaluation = d_ex;
1833: (*s_etat_processus).derniere_erreur_fonction_externe = 0;
1834:
1835: (*s_etat_processus).erreur_processus_fils = d_faux;
1836: (*s_etat_processus).erreur_systeme_processus_fils = d_es;
1837: (*s_etat_processus).erreur_execution_processus_fils = d_ex;
1838: (*s_etat_processus).pid_erreur_processus_fils = 0;
1839: (*s_etat_processus).exception_processus_fils = d_ep;
1840: (*s_etat_processus).core = core;
1841: (*s_etat_processus).invalidation_message_erreur = d_faux;
1842: (*s_etat_processus).s_objet_errone = NULL;
1843: (*s_etat_processus).s_objet_erreur = NULL;
1844:
1845: (*s_etat_processus).retour_routine_evaluation = 'N';
1846:
1847: (*s_etat_processus).traitement_interruption = 'N';
1848: (*s_etat_processus).traitement_interruptible = 'Y';
1849: (*s_etat_processus).nombre_interruptions_en_queue = 0;
1850: (*s_etat_processus).nombre_interruptions_non_affectees = 0;
1851:
1852: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
1853: {
1854: (*s_etat_processus).masque_interruptions[i] = 'N';
1855: (*s_etat_processus).queue_interruptions[i] = 0;
1856: (*s_etat_processus).corps_interruptions[i] = NULL;
1857: (*s_etat_processus).pile_origine_interruptions[i] = NULL;
1858: }
1859:
1860: (*s_etat_processus).at_exit = NULL;
1861:
1862: (*s_etat_processus).pointeurs_caracteres = NULL;
1863: (*s_etat_processus).arbre_instructions = NULL;
1864:
1865: (*s_etat_processus).tid_processus_pere = pthread_self();
1866: (*s_etat_processus).pid_processus_pere = getpid();
1867: (*s_etat_processus).processus_detache = d_vrai;
1868: (*s_etat_processus).var_volatile_processus_pere = -1;
1869: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
1870: (*s_etat_processus).var_volatile_alarme = 0;
1871: (*s_etat_processus).var_volatile_requete_arret = 0;
1872: (*s_etat_processus).var_volatile_requete_arret2 = 0;
1873: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
1874: (*s_etat_processus).var_volatile_traitement_sigint = 0;
1875: (*s_etat_processus).var_volatile_recursivite = 0;
1876: (*s_etat_processus).var_volatile_exception_gsl = 0;
1877: (*s_etat_processus).arret_depuis_abort = 0;
1878:
1879: initialisation_allocateur(s_etat_processus);
1880: initialisation_drapeaux(s_etat_processus);
1881:
1882: if ((*s_etat_processus).erreur_systeme != d_es)
1883: {
1884: if ((*s_etat_processus).langue == 'F')
1885: {
1886: printf("+++Système : Mémoire insuffisante\n");
1887: }
1888: else
1889: {
1890: printf("+++System : Not enough memory\n");
1891: }
1892:
1893: return(EXIT_FAILURE);
1894: }
1895:
1896: if (((*s_etat_processus).instruction_derniere_erreur =
1897: malloc(2 * sizeof(unsigned char))) == NULL)
1898: {
1899: erreur = d_es_allocation_memoire;
1900:
1901: if ((*s_etat_processus).langue == 'F')
1902: {
1903: printf("+++Système : Mémoire insuffisante\n");
1904: }
1905: else
1906: {
1907: printf("+++System : Not enough memory\n");
1908: }
1909:
1910: return(EXIT_FAILURE);
1911: }
1912:
1913: strcpy((*s_etat_processus).instruction_derniere_erreur, "");
1914: (*s_etat_processus).niveau_derniere_erreur = 0;
1915:
1916: if (traitement_fichier_temporaire == 'Y')
1917: {
1918: (*s_etat_processus).mode_interactif = 'Y';
1919: }
1920: else
1921: {
1922: (*s_etat_processus).mode_interactif = 'N';
1923: }
1924:
1925: if (((*s_etat_processus).instruction_courante = (unsigned char *)
1926: malloc(sizeof(unsigned char))) == NULL)
1927: {
1928: erreur = d_es_allocation_memoire;
1929:
1930: if ((*s_etat_processus).langue == 'F')
1931: {
1932: printf("+++Système : Mémoire insuffisante\n");
1933: }
1934: else
1935: {
1936: printf("+++System : Not enough memory\n");
1937: }
1938:
1939: return(EXIT_FAILURE);
1940: }
1941:
1942: (*s_etat_processus).instruction_courante[0] = d_code_fin_chaine;
1943:
1944: empilement_pile_systeme(s_etat_processus);
1945:
1946: free((*s_etat_processus).instruction_courante);
1947:
1948: if ((*s_etat_processus).erreur_systeme == d_es_allocation_memoire)
1949: {
1950: erreur = d_es_allocation_memoire;
1951: }
1952: else
1953: {
1954: (*((*s_etat_processus).l_base_pile_systeme))
1955: .retour_definition = 'Y';
1956:
1957: (*s_etat_processus).indep = (struct_objet *) malloc(
1958: sizeof(struct_objet));
1959: (*s_etat_processus).depend = (struct_objet *) malloc(
1960: sizeof(struct_objet));
1961: (*s_etat_processus).parametres_courbes_de_niveau =
1962: (struct_objet *) malloc(sizeof(struct_objet));
1963:
1964: if (((*s_etat_processus).indep != NULL) &&
1965: ((*s_etat_processus).depend != NULL) &&
1966: ((*s_etat_processus).parametres_courbes_de_niveau
1967: != NULL))
1968: {
1969: (*((*s_etat_processus).indep)).type = NOM;
1970: (*((*s_etat_processus).depend)).type = NOM;
1971: (*((*s_etat_processus).
1972: parametres_courbes_de_niveau)).type = LST;
1973:
1974: initialisation_objet((*s_etat_processus).indep);
1975: initialisation_objet((*s_etat_processus).depend);
1976: initialisation_objet((*s_etat_processus)
1977: .parametres_courbes_de_niveau);
1978:
1979: (*((*s_etat_processus).indep)).objet = (struct_nom *)
1980: malloc(sizeof(struct_nom));
1981: (*((*s_etat_processus).depend)).objet = (struct_nom *)
1982: malloc(sizeof(struct_nom));
1983: (*((*s_etat_processus).parametres_courbes_de_niveau))
1984: .objet = (struct_liste_chainee *)
1985: malloc(sizeof(struct_liste_chainee));
1986:
1987: if (((*((*s_etat_processus).depend)).objet == NULL) ||
1988: ((*((*s_etat_processus).depend)).objet == NULL) ||
1989: ((*((*s_etat_processus).
1990: parametres_courbes_de_niveau)).objet == NULL))
1991: {
1992: erreur = d_es_allocation_memoire;
1993:
1994: if ((*s_etat_processus).langue == 'F')
1995: {
1996: printf("+++Système : Mémoire insuffisante\n");
1997: }
1998: else
1999: {
2000: printf("+++System : Not enough memory\n");
2001: }
2002:
2003: return(EXIT_FAILURE);
2004: }
2005:
2006: (*((struct_nom *) (*((*s_etat_processus).indep)).objet))
2007: .nom = malloc(2 * sizeof(unsigned char));
2008: (*((struct_nom *) (*((*s_etat_processus).depend)).objet))
2009: .nom = malloc(2 * sizeof(unsigned char));
2010:
2011: if (((*((struct_nom *) (*((*s_etat_processus).indep))
2012: .objet)).nom == NULL) || ((*((struct_nom *)
2013: (*((*s_etat_processus).depend)).objet)).nom ==
2014: NULL))
2015: {
2016: erreur = d_es_allocation_memoire;
2017:
2018: if ((*s_etat_processus).langue == 'F')
2019: {
2020: printf("+++Système : Mémoire insuffisante\n");
2021: }
2022: else
2023: {
2024: printf("+++System : Not enough memory\n");
2025: }
2026:
2027: return(EXIT_FAILURE);
2028: }
2029:
2030: strcpy((*((struct_nom *) (*((*s_etat_processus).indep))
2031: .objet)).nom, "X");
2032: strcpy((*((struct_nom *) (*((*s_etat_processus).depend))
2033: .objet)).nom, "Y");
2034:
2035: (*((struct_nom *) (*((*s_etat_processus).indep))
2036: .objet)).symbole = d_vrai;
2037: (*((struct_nom *) (*((*s_etat_processus).depend))
2038: .objet)).symbole = d_vrai;
2039:
2040: (*((struct_liste_chainee *) (*((*s_etat_processus)
2041: .parametres_courbes_de_niveau)).objet)).suivant
2042: = NULL;
2043:
2044: (*((struct_liste_chainee *) (*((*s_etat_processus)
2045: .parametres_courbes_de_niveau)).objet)).donnee
2046: = malloc(sizeof(struct_objet));
2047:
2048: (*s_etat_processus).legende =
2049: malloc(sizeof(unsigned char));
2050: (*s_etat_processus).label_x =
2051: malloc(sizeof(unsigned char));
2052: (*s_etat_processus).label_y =
2053: malloc(sizeof(unsigned char));
2054: (*s_etat_processus).label_z =
2055: malloc(sizeof(unsigned char));
2056: (*s_etat_processus).titre =
2057: malloc(sizeof(unsigned char));
2058:
2059: if (((*s_etat_processus).label_x == NULL) ||
2060: ((*s_etat_processus).label_y == NULL) ||
2061: ((*s_etat_processus).label_z == NULL) ||
2062: ((*s_etat_processus).titre == NULL) ||
2063: ((*s_etat_processus).legende == NULL) ||
2064: ((*((struct_liste_chainee *) (*((*s_etat_processus)
2065: .parametres_courbes_de_niveau)).objet)).donnee
2066: == NULL))
2067: {
2068: erreur = d_es_allocation_memoire;
2069:
2070: if ((*s_etat_processus).langue == 'F')
2071: {
2072: printf("+++Système : Mémoire insuffisante\n");
2073: }
2074: else
2075: {
2076: printf("+++System : Not enough memory\n");
2077: }
2078:
2079: return(EXIT_FAILURE);
2080: }
2081:
2082: (*(*((struct_liste_chainee *) (*((*s_etat_processus)
2083: .parametres_courbes_de_niveau)).objet)).donnee)
2084: .type = CHN;
2085:
2086: initialisation_objet((*((struct_liste_chainee *)
2087: (*((*s_etat_processus)
2088: .parametres_courbes_de_niveau))
2089: .objet)).donnee);
2090:
2091: if (((*(*((struct_liste_chainee *) (*((*s_etat_processus)
2092: .parametres_courbes_de_niveau)).objet)).donnee)
2093: .objet = malloc(10 * sizeof(unsigned char)))
2094: == NULL)
2095: {
2096: erreur = d_es_allocation_memoire;
2097:
2098: if ((*s_etat_processus).langue == 'F')
2099: {
2100: printf("+++Système : Mémoire insuffisante\n");
2101: }
2102: else
2103: {
2104: printf("+++System : Not enough memory\n");
2105: }
2106:
2107: return(EXIT_FAILURE);
2108: }
2109:
2110: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
2111: (*((*s_etat_processus)
2112: .parametres_courbes_de_niveau))
2113: .objet)).donnee).objet, "AUTOMATIC");
2114:
2115: (*s_etat_processus).label_x[0] = d_code_fin_chaine;
2116: (*s_etat_processus).label_y[0] = d_code_fin_chaine;
2117: (*s_etat_processus).label_z[0] = d_code_fin_chaine;
2118: (*s_etat_processus).titre[0] = d_code_fin_chaine;
2119: (*s_etat_processus).legende[0] = d_code_fin_chaine;
2120:
2121: (*s_etat_processus).nom_fichier_gnuplot = NULL;
2122: (*s_etat_processus).type_fichier_gnuplot = NULL;
2123:
2124: (*s_etat_processus).x_tics = 0;
2125: (*s_etat_processus).y_tics = 0;
2126: (*s_etat_processus).z_tics = 0;
2127:
2128: (*s_etat_processus).x_lines = d_vrai;
2129: (*s_etat_processus).y_lines = d_vrai;
2130: (*s_etat_processus).z_lines = d_vrai;
2131:
2132: (*s_etat_processus).mx_tics = -1;
2133: (*s_etat_processus).my_tics = -1;
2134: (*s_etat_processus).mz_tics = -1;
2135:
2136: (*s_etat_processus).mx_lines = d_faux;
2137: (*s_etat_processus).my_lines = d_faux;
2138: (*s_etat_processus).mz_lines = d_faux;
2139:
2140: (*s_etat_processus).x2_tics = -1;
2141: (*s_etat_processus).y2_tics = -1;
2142: (*s_etat_processus).z2_tics = -1;
2143:
2144: (*s_etat_processus).x2_lines = d_faux;
2145: (*s_etat_processus).y2_lines = d_faux;
2146: (*s_etat_processus).z2_lines = d_faux;
2147:
2148: (*s_etat_processus).mx2_tics = -1;
2149: (*s_etat_processus).my2_tics = -1;
2150: (*s_etat_processus).mz2_tics = -1;
2151:
2152: (*s_etat_processus).mx2_lines = d_faux;
2153: (*s_etat_processus).my2_lines = d_faux;
2154: (*s_etat_processus).mz2_lines = d_faux;
2155:
2156: if ((*s_etat_processus).erreur_systeme != d_es)
2157: {
2158: if ((*s_etat_processus).langue == 'F')
2159: {
2160: printf("+++Système : Mémoire insuffisante\n");
2161: }
2162: else
2163: {
2164: printf("+++System : Not enough memory\n");
2165: }
2166:
2167: return(EXIT_FAILURE);
2168: }
2169:
2170: (*s_etat_processus).mode_evaluation_expression = 'N';
2171: (*s_etat_processus).mode_execution_programme = 'Y';
2172:
2173: if ((*s_etat_processus).definitions_chainees == NULL)
2174: {
2175: if ((erreur = chainage(s_etat_processus)) !=
2176: d_absence_erreur)
2177: {
2178: if ((*s_etat_processus).langue == 'F')
2179: {
2180: printf("+++Fatal :"
2181: " Chaînage des définitions"
2182: " impossible\n");
2183: }
2184: else
2185: {
2186: printf("+++Fatal : Error in "
2187: "compilation\n");
2188: }
2189:
2190: if (traitement_fichier_temporaire == 'Y')
2191: {
2192: if (destruction_fichier(
2193: nom_fichier_temporaire)
2194: == d_erreur)
2195: {
2196: return(EXIT_FAILURE);
2197: }
2198:
2199: free(nom_fichier_temporaire);
2200: }
2201:
2202: return(EXIT_FAILURE);
2203: }
2204: }
2205:
2206: if ((erreur = compilation(s_etat_processus)) !=
2207: d_absence_erreur)
2208: {
2209: if (traitement_fichier_temporaire == 'Y')
2210: {
2211: if (destruction_fichier(nom_fichier_temporaire)
2212: == d_erreur)
2213: {
2214: return(EXIT_FAILURE);
2215: }
2216:
2217: free(nom_fichier_temporaire);
2218: }
2219:
2220: printf("%s [%d]\n", message =
2221: messages(s_etat_processus), (int) getpid());
2222: free(message);
2223:
2224: if (test_cfsf(s_etat_processus, 51) == d_faux)
2225: {
2226: printf("%s", ds_beep);
2227: }
2228:
2229: if ((*s_etat_processus).core == d_vrai)
2230: {
2231: printf("\n");
2232:
2233: if ((*s_etat_processus).langue == 'F')
2234: {
2235: printf("+++Information : Génération du fichier "
2236: "rpl-core [%d]\n", (int) getpid());
2237: }
2238: else
2239: {
2240: printf("+++Information : Writing rpl-core "
2241: "file [%d]\n", (int) getpid());
2242: }
2243:
2244: rplcore(s_etat_processus);
2245:
2246: if ((*s_etat_processus).langue == 'F')
2247: {
2248: printf("+++Information : Processus tracé "
2249: "[%d]\n", (int) getpid());
2250: }
2251: else
2252: {
2253: printf("+++Information : Done [%d]\n",
2254: (int) getpid());
2255: }
2256:
2257: printf("\n");
2258: }
2259:
2260: return(EXIT_FAILURE);
2261: }
2262:
2263: (*s_etat_processus).position_courante = 0;
2264: (*s_etat_processus).traitement_cycle_exit = 'N';
2265:
2266: if ((*s_etat_processus).nombre_variables == 0)
2267: {
2268: if ((*s_etat_processus).langue == 'F')
2269: {
2270: printf("+++Fatal : Aucun point d'entrée\n");
2271: }
2272: else
2273: {
2274: printf("+++Fatal : Any entry point\n");
2275: }
2276:
2277: if (test_cfsf(s_etat_processus, 51) == d_faux)
2278: {
2279: printf("%s", ds_beep);
2280: }
2281:
2282: return(EXIT_FAILURE);
2283: }
2284:
2285: if (recherche_instruction_suivante(s_etat_processus)
2286: == d_erreur)
2287: {
2288: if ((*s_etat_processus).langue == 'F')
2289: {
2290: printf("+++Fatal : Aucun point d'entrée\n");
2291: }
2292: else
2293: {
2294: printf("+++Fatal : Any entry point\n");
2295: }
2296:
2297: if (test_cfsf(s_etat_processus, 51) == d_faux)
2298: {
2299: printf("%s", ds_beep);
2300: }
2301:
2302: return(EXIT_FAILURE);
2303: }
2304:
2305: if (recherche_variable(s_etat_processus,
2306: (*s_etat_processus)
2307: .instruction_courante) == d_faux)
2308: {
2309: if ((*s_etat_processus).langue == 'F')
2310: {
2311: printf("+++Fatal : Aucun point d'entrée\n");
2312: }
2313: else
2314: {
2315: printf("+++Fatal : Any entry point\n");
2316: }
2317:
2318: if (test_cfsf(s_etat_processus, 51) == d_faux)
2319: {
2320: printf("%s", ds_beep);
2321: }
2322:
2323: return(EXIT_FAILURE);
2324: }
2325:
2326: if ((*s_etat_processus).s_liste_variables
2327: [(*s_etat_processus)
2328: .position_variable_courante].niveau != 0)
2329: {
2330: if ((*s_etat_processus).langue == 'F')
2331: {
2332: printf("+++Fatal : Aucun point d'entrée\n");
2333: }
2334: else
2335: {
2336: printf("+++Fatal : Any entry point\n");
2337: }
2338:
2339: if (test_cfsf(s_etat_processus, 51) == d_faux)
2340: {
2341: printf("%s", ds_beep);
2342: }
2343:
2344: return(EXIT_FAILURE);
2345: }
2346:
2347: free((*s_etat_processus).instruction_courante);
2348: (*s_etat_processus).position_courante = 0;
2349:
2350: if (((*s_etat_processus).nom_fichier_historique =
2351: malloc((strlen(home) +
2352: strlen(ds_fichier_historique) + 2) *
2353: sizeof(unsigned char))) == NULL)
2354: {
2355: erreur = d_es_allocation_memoire;
2356:
2357: if ((*s_etat_processus).langue == 'F')
2358: {
2359: printf("+++Système : Mémoire insuffisante\n");
2360: }
2361: else
2362: {
2363: printf("+++System : Not enough memory\n");
2364: }
2365:
2366: return(EXIT_FAILURE);
2367: }
2368:
2369: sprintf((*s_etat_processus).nom_fichier_historique, "%s/%s",
2370: home, ds_fichier_historique);
2371:
2372: using_history();
2373: erreur_historique = read_history(
2374: (*s_etat_processus).nom_fichier_historique);
2375:
2376: gsl_set_error_handler(&traitement_exceptions_gsl);
2377:
2378: if (drapeau_encart == 'Y')
2379: {
2380: (*s_etat_processus).erreur_systeme = d_es;
2381: encart(s_etat_processus,
2382: (unsigned long) (5 * 1000000));
2383:
2384: if ((*s_etat_processus).erreur_systeme != d_es)
2385: {
2386: if ((message = messages(s_etat_processus))
2387: == NULL)
2388: {
2389: erreur = d_es_allocation_memoire;
2390:
2391: if ((*s_etat_processus).langue == 'F')
2392: {
2393: printf("+++Système : Mémoire "
2394: "insuffisante\n");
2395: }
2396: else
2397: {
2398: printf("+++System : Not enough "
2399: "memory\n");
2400: }
2401:
2402: return(EXIT_FAILURE);
2403: }
2404:
2405: printf("%s [%d]\n", message, (int) getpid());
2406: free(message);
2407:
2408: return(EXIT_FAILURE);
2409: }
2410: }
2411:
2412: fflush(stdout);
2413:
2414: initialisation_instructions(s_etat_processus);
2415:
2416: if (arguments != NULL)
2417: {
2418: tampon = (*s_etat_processus).definitions_chainees;
2419: (*s_etat_processus).definitions_chainees =
2420: arguments;
2421:
2422: if (analyse_syntaxique(s_etat_processus) ==
2423: d_erreur)
2424: {
2425: if ((*s_etat_processus).erreur_systeme != d_es)
2426: {
2427: erreur = d_es_allocation_memoire;
2428:
2429: if ((*s_etat_processus).langue == 'F')
2430: {
2431: printf("+++Système : Mémoire "
2432: "insuffisante\n");
2433: }
2434: else
2435: {
2436: printf("+++System : Not enough "
2437: "memory\n");
2438: }
2439:
2440: return(EXIT_FAILURE);
2441: }
2442: else
2443: {
2444: if ((*s_etat_processus).langue == 'F')
2445: {
2446: printf("+++Erreur : Erreur de "
2447: "syntaxe\n");
2448: }
2449: else
2450: {
2451: printf("+++Error : Syntax error\n");
2452: }
2453:
2454: return(EXIT_FAILURE);
2455: }
2456: }
2457:
2458: (*s_etat_processus).instruction_courante
2459: = arguments;
2460: (*s_etat_processus).definitions_chainees = tampon;
2461: (*s_etat_processus).position_courante = 0;
2462:
2463: recherche_type(s_etat_processus);
2464:
2465: if ((*s_etat_processus).erreur_systeme != d_es)
2466: {
2467: if ((message = messages(s_etat_processus))
2468: == NULL)
2469: {
2470: erreur = d_es_allocation_memoire;
2471:
2472: if ((*s_etat_processus).langue == 'F')
2473: {
2474: printf("+++Système : Mémoire "
2475: "insuffisante\n");
2476: }
2477: else
2478: {
2479: printf("+++System : Not enough "
2480: "memory\n");
2481: }
2482:
2483: return(EXIT_FAILURE);
2484: }
2485:
2486: printf("%s [%d]\n", message, (int) getpid());
2487: free(message);
2488:
2489: return(EXIT_FAILURE);
2490: }
2491:
2492: if ((*s_etat_processus).erreur_execution != d_ex)
2493: {
2494: if ((message = messages(s_etat_processus))
2495: == NULL)
2496: {
2497: erreur = d_es_allocation_memoire;
2498:
2499: if ((*s_etat_processus).langue == 'F')
2500: {
2501: printf("+++Erreur : Mémoire "
2502: "insuffisante\n");
2503: }
2504: else
2505: {
2506: printf("+++Error : Not enough "
2507: "memory\n");
2508: }
2509:
2510: return(EXIT_FAILURE);
2511: }
2512:
2513: printf("%s [%d]\n", message, (int) getpid());
2514: free(message);
2515:
2516: return(EXIT_FAILURE);
2517: }
2518:
2519: if (depilement(s_etat_processus,
2520: &((*s_etat_processus).l_base_pile),
2521: &s_objet) == d_erreur)
2522: {
2523: if ((message = messages(s_etat_processus))
2524: == NULL)
2525: {
2526: erreur = d_es_allocation_memoire;
2527:
2528: if ((*s_etat_processus).langue == 'F')
2529: {
2530: printf("+++Erreur : Mémoire "
2531: "insuffisante\n");
2532: }
2533: else
2534: {
2535: printf("+++Error : Not enough "
2536: "memory\n");
2537: }
2538:
2539: return(EXIT_FAILURE);
2540: }
2541:
2542: printf("%s [%d]\n", message, (int) getpid());
2543: free(message);
2544:
2545: return(EXIT_FAILURE);
2546: }
2547:
2548: if (evaluation(s_etat_processus, s_objet, 'E')
2549: == d_erreur)
2550: {
2551: if ((*s_etat_processus).erreur_systeme != d_es)
2552: {
2553: if ((message = messages(s_etat_processus))
2554: == NULL)
2555: {
2556: erreur = d_es_allocation_memoire;
2557:
2558: if ((*s_etat_processus).langue == 'F')
2559: {
2560: printf("+++Système : Mémoire "
2561: "insuffisante\n");
2562: }
2563: else
2564: {
2565: printf("+++System : Not enough "
2566: "memory\n");
2567: }
2568:
2569: return(EXIT_FAILURE);
2570: }
2571:
2572: printf("%s [%d]\n", message,
2573: (int) getpid());
2574: free(message);
2575:
2576: return(EXIT_FAILURE);
2577: }
2578:
2579: if ((*s_etat_processus).erreur_execution
2580: != d_ex)
2581: {
2582: if ((message = messages(s_etat_processus))
2583: == NULL)
2584: {
2585: erreur = d_es_allocation_memoire;
2586:
2587: if ((*s_etat_processus).langue == 'F')
2588: {
2589: printf("+++Erreur : Mémoire "
2590: "insuffisante\n");
2591: }
2592: else
2593: {
2594: printf("+++Error : Not enough "
2595: "memory\n");
2596: }
2597:
2598: return(EXIT_FAILURE);
2599: }
2600:
2601: printf("%s [%d]\n", message,
2602: (int) getpid());
2603: free(message);
2604:
2605: return(EXIT_FAILURE);
2606: }
2607: }
2608:
2609: (*s_etat_processus).instruction_courante = NULL;
2610: liberation(s_etat_processus, s_objet);
2611:
2612: free(arguments);
2613: }
2614:
2615: if (option_a == d_vrai)
2616: {
2617: fprintf(stdout, "%s\n", (*s_etat_processus)
2618: .definitions_chainees);
2619: }
2620: else
2621: {
2622: if (option_D == d_vrai)
2623: {
2624: lancement_daemon(s_etat_processus);
2625: }
2626:
2627: if (option_p == d_faux)
2628: {
2629: if (setjmp(contexte_initial) == 0)
2630: {
2631: erreur = sequenceur(s_etat_processus);
2632: }
2633: }
2634: else
2635: {
2636: if (setjmp(contexte_initial) == 0)
2637: {
2638: erreur = sequenceur_optimise(s_etat_processus);
2639: }
2640: }
2641:
2642: if (erreur == d_absence_erreur)
2643: {
2644: if (((*s_etat_processus).var_volatile_alarme == 0)
2645: && ((*s_etat_processus).arret_depuis_abort
2646: == 0) && ((*s_etat_processus).at_exit
2647: != NULL))
2648: {
2649: erreur = evaluation(s_etat_processus,
2650: (*s_etat_processus).at_exit, 'E');
2651: }
2652: }
2653:
2654: liberation(s_etat_processus,
2655: (*s_etat_processus).at_exit);
2656: }
2657:
2658: if ((*s_etat_processus).generateur_aleatoire != NULL)
2659: {
2660: liberation_generateur_aleatoire(s_etat_processus);
2661: }
2662:
2663: l_element_courant = (*s_etat_processus).liste_mutexes;
2664: while(l_element_courant != NULL)
2665: {
2666: pthread_mutex_trylock(&((*((struct_mutex *)
2667: (*(*((struct_liste_chainee *)
2668: l_element_courant)).donnee).objet)).mutex));
2669: pthread_mutex_unlock(&((*((struct_mutex *)
2670: (*(*((struct_liste_chainee *)
2671: l_element_courant)).donnee).objet)).mutex));
2672: pthread_mutex_destroy(&((*((struct_mutex *)
2673: (*(*((struct_liste_chainee *)
2674: l_element_courant)).donnee).objet)).mutex));
2675:
2676: liberation(s_etat_processus,
2677: (*((struct_liste_chainee *)
2678: l_element_courant)).donnee);
2679: l_element_suivant = (*((struct_liste_chainee *)
2680: l_element_courant)).suivant;
2681: free((struct_liste_chainee *) l_element_courant);
2682: l_element_courant = l_element_suivant;
2683: }
2684:
2685: /*
2686: * Arrêt des processus fils
2687: */
2688:
2689: if ((*s_etat_processus).presence_fusible == d_vrai)
2690: {
2691: pthread_cancel((*s_etat_processus).thread_fusible);
2692: }
2693:
2694: pthread_mutex_lock(&((*s_etat_processus).mutex));
2695:
2696: l_element_courant = (void *) (*s_etat_processus)
2697: .l_base_pile_processus;
2698:
2699: while(l_element_courant != NULL)
2700: {
2701: if ((*s_etat_processus).debug == d_vrai)
2702: {
2703: if (((*s_etat_processus).type_debug &
2704: d_debug_processus) != 0)
2705: {
2706: if ((*(*((struct_processus_fils *)
2707: (*(*((struct_liste_chainee *)
2708: l_element_courant)).donnee)
2709: .objet)).thread)
2710: .processus_detache == d_vrai)
2711: {
2712: if ((*s_etat_processus).langue == 'F')
2713: {
2714: printf("[%d] Signalement pour arrêt du "
2715: "processus %d\n",
2716: (int) getpid(), (int)
2717: (*(*((struct_processus_fils *)
2718: (*(*((struct_liste_chainee *)
2719: l_element_courant)).donnee)
2720: .objet)).thread).pid);
2721: }
2722: else
2723: {
2724: printf("[%d] Send stop signal to "
2725: "process %d\n",
2726: (int) getpid(), (int)
2727: (*(*((struct_processus_fils *)
2728: (*(*((struct_liste_chainee *)
2729: l_element_courant)).donnee)
2730: .objet)).thread).pid);
2731: }
2732: }
2733: else
2734: {
2735: if ((*s_etat_processus).langue == 'F')
2736: {
2737: printf("[%d] Signalement pour arrêt du "
2738: "thread %llu\n", (int) getpid(),
2739: (unsigned long long)
2740: (*(*((struct_processus_fils *)
2741: (*(*((struct_liste_chainee *)
2742: l_element_courant)).donnee)
2743: .objet)).thread).tid);
2744: }
2745: else
2746: {
2747: printf("[%d] Send stop signal to "
2748: "thread %llu\n",
2749: (int) getpid(),
2750: (unsigned long long)
2751: (*(*((struct_processus_fils *)
2752: (*(*((struct_liste_chainee *)
2753: l_element_courant)).donnee)
2754: .objet)).thread).tid);
2755: }
2756: }
2757: }
2758: }
2759:
2760: if ((*(*((struct_processus_fils *)
2761: (*(*((struct_liste_chainee *)
2762: l_element_courant)).donnee).objet))
2763: .thread).processus_detache == d_vrai)
2764: {
2765: if ((*s_etat_processus).var_volatile_alarme != 0)
2766: {
2767: kill((*(*((struct_processus_fils *)
2768: (*(*((struct_liste_chainee *)
2769: l_element_courant)).donnee).objet))
2770: .thread).pid, SIGURG);
2771: }
2772: else
2773: {
2774: if ((*s_etat_processus).arret_depuis_abort
2775: == -1)
2776: {
2777: kill((*(*((struct_processus_fils *)
2778: (*(*((struct_liste_chainee *)
2779: l_element_courant)).donnee).objet))
2780: .thread).pid, SIGFABORT);
2781: }
2782: else
2783: {
2784: kill((*(*((struct_processus_fils *)
2785: (*(*((struct_liste_chainee *)
2786: l_element_courant)).donnee).objet))
2787: .thread).pid, SIGFSTOP);
2788: }
2789: }
2790: }
2791: else
2792: {
2793: pthread_mutex_lock(&((*(*((struct_processus_fils *)
2794: (*(*((struct_liste_chainee *)
2795: l_element_courant)).donnee).objet)).thread)
2796: .mutex));
2797:
2798: if ((*(*((struct_processus_fils *)
2799: (*(*((struct_liste_chainee *)
2800: l_element_courant)).donnee).objet)).thread)
2801: .thread_actif == d_vrai)
2802: {
2803: if ((*s_etat_processus).var_volatile_alarme
2804: != 0)
2805: {
2806: pthread_kill((*(*((struct_processus_fils *)
2807: (*(*((struct_liste_chainee *)
2808: l_element_courant)).donnee).objet))
2809: .thread).tid, SIGURG);
2810: }
2811: else
2812: {
2813: if ((*s_etat_processus).arret_depuis_abort
2814: == -1)
2815: {
2816: pthread_kill(
2817: (*(*((struct_processus_fils *)
2818: (*(*((struct_liste_chainee *)
2819: l_element_courant)).donnee)
2820: .objet)).thread).tid,
2821: SIGFABORT);
2822: }
2823: else
2824: {
2825: pthread_kill(
2826: (*(*((struct_processus_fils *)
2827: (*(*((struct_liste_chainee *)
2828: l_element_courant)).donnee)
2829: .objet)).thread).tid,
2830: SIGFSTOP);
2831: }
2832: }
2833: }
2834:
2835: pthread_mutex_unlock(
2836: &((*(*((struct_processus_fils *)
2837: (*(*((struct_liste_chainee *)
2838: l_element_courant)).donnee).objet)).thread)
2839: .mutex));
2840: }
2841:
2842: l_element_courant = (*((struct_liste_chainee *)
2843: l_element_courant)).suivant;
2844: }
2845:
2846: /*
2847: * Attente de la fin de tous les processus fils
2848: */
2849:
2850: for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
2851: (*s_etat_processus).masque_interruptions[i++]
2852: = 'I');
2853:
2854: attente.tv_sec = 0;
2855: attente.tv_nsec = GRANULARITE_us * 1000;
2856:
2857: while((*s_etat_processus).l_base_pile_processus != NULL)
2858: {
2859: status = 0;
2860:
2861: l_element_courant = (void *)
2862: (*s_etat_processus).l_base_pile_processus;
2863:
2864: for(i = 0; i < (unsigned long)
2865: (*(*((struct_processus_fils *)
2866: (*(*((struct_liste_chainee *)
2867: l_element_courant)).donnee).objet)).thread)
2868: .nombre_objets_dans_pipe; i++)
2869: {
2870: if ((s_objet = lecture_pipe(
2871: s_etat_processus,
2872: (*(*((struct_processus_fils *)
2873: (*(*((struct_liste_chainee *)
2874: l_element_courant)).donnee).objet)).thread)
2875: .pipe_objets[0])) != NULL)
2876: {
2877: liberation(s_etat_processus, s_objet);
2878:
2879: (*(*((struct_processus_fils *)
2880: (*(*((struct_liste_chainee *)
2881: l_element_courant)).donnee).objet))
2882: .thread).nombre_objets_dans_pipe--;
2883:
2884: action.sa_handler = SIG_IGN;
2885: action.sa_flags = SA_ONSTACK;
2886:
2887: if (sigaction(SIGPIPE, &action, ®istre)
2888: != 0)
2889: {
2890: pthread_mutex_unlock(
2891: &((*s_etat_processus).mutex));
2892: return(EXIT_FAILURE);
2893: }
2894:
2895: while((longueur_ecriture =
2896: write_atomic(s_etat_processus,
2897: (*(*((struct_processus_fils *)
2898: (*(*((struct_liste_chainee *)
2899: l_element_courant)).donnee).objet))
2900: .thread).pipe_nombre_injections[1], "+",
2901: sizeof(unsigned char))) !=
2902: sizeof(unsigned char))
2903: {
2904: if (longueur_ecriture == -1)
2905: {
2906: // Le processus n'existe plus.
2907: break;
2908: }
2909: }
2910:
2911: if (sigaction(SIGPIPE, ®istre, NULL)
2912: != 0)
2913: {
2914: pthread_mutex_unlock(
2915: &((*s_etat_processus).mutex));
2916: return(EXIT_FAILURE);
2917: }
2918: }
2919: }
2920:
2921: pthread_mutex_unlock(&((*s_etat_processus).mutex));
2922:
2923: if ((*s_etat_processus)
2924: .nombre_interruptions_non_affectees != 0)
2925: {
2926: affectation_interruptions_logicielles(
2927: s_etat_processus);
2928: }
2929:
2930: nanosleep(&attente, NULL);
2931: pthread_mutex_lock(&((*s_etat_processus).mutex));
2932: }
2933:
2934: pthread_mutex_unlock(&((*s_etat_processus).mutex));
2935:
2936: erreur_historique = write_history(
2937: (*s_etat_processus).nom_fichier_historique);
2938: clear_history();
2939:
2940: if (erreur_historique != 0)
2941: {
2942: if ((*s_etat_processus).langue == 'F')
2943: {
2944: printf("+++Erreur : L'historique ne peut être "
2945: "écrit\n");
2946: }
2947: else
2948: {
2949: printf("+++Error : History cannot be "
2950: "written\n");
2951: }
2952:
2953: if (test_cfsf(s_etat_processus, 51) == d_faux)
2954: {
2955: printf("%s", ds_beep);
2956: }
2957: }
2958:
2959: free((*s_etat_processus).nom_fichier_historique);
2960:
2961: if (((*s_etat_processus).core == d_vrai) &&
2962: (erreur == d_erreur) &&
2963: ((*s_etat_processus).var_volatile_traitement_sigint
2964: == 0))
2965: {
2966: printf("\n");
2967:
2968: if ((*s_etat_processus).langue == 'F')
2969: {
2970: printf("+++Information : Génération du fichier "
2971: "rpl-core [%d]\n", (int) getpid());
2972: }
2973: else
2974: {
2975: printf("+++Information : Writing rpl-core "
2976: "file [%d]\n", (int) getpid());
2977: }
2978:
2979: rplcore(s_etat_processus);
2980:
2981: if ((*s_etat_processus).langue == 'F')
2982: {
2983: printf("+++Information : Processus tracé [%d]\n",
2984: (int) getpid());
2985: }
2986: else
2987: {
2988: printf("+++Information : Done [%d]\n",
2989: (int) getpid());
2990: }
2991:
2992: printf("\n");
2993: }
2994:
2995: free((*s_etat_processus).definitions_chainees);
2996:
2997: /*
2998: * Libération de l'arbre des instructions
2999: */
3000:
3001: liberation_arbre_instructions(s_etat_processus,
3002: (*s_etat_processus).arbre_instructions);
3003: free((*s_etat_processus).pointeurs_caracteres);
3004:
3005: if ((*s_etat_processus).entree_standard != NULL)
3006: {
3007: pclose((*s_etat_processus).entree_standard);
3008: (*s_etat_processus).entree_standard = NULL;
3009: }
3010:
3011: if ((*s_etat_processus).nom_fichier_impression != NULL)
3012: {
3013: if (test_cfsf(s_etat_processus, 51) == d_faux)
3014: {
3015: printf("%s", ds_beep);
3016: }
3017:
3018: if ((*s_etat_processus).langue == 'F')
3019: {
3020: printf("+++Attention : Queue d'impression "
3021: "non vide !\n");
3022: }
3023: else
3024: {
3025: printf("+++Warning : Non empty printing "
3026: "spool queue !\n");
3027: }
3028:
3029: instruction_erase(s_etat_processus);
3030: }
3031:
3032: if ((*s_etat_processus).fichiers_graphiques != NULL)
3033: {
3034: instruction_cllcd(s_etat_processus);
3035: }
3036:
3037: liberation(s_etat_processus, (*s_etat_processus).indep);
3038: liberation(s_etat_processus, (*s_etat_processus).depend);
3039:
3040: free((*s_etat_processus).label_x);
3041: free((*s_etat_processus).label_y);
3042: free((*s_etat_processus).label_z);
3043: free((*s_etat_processus).titre);
3044: free((*s_etat_processus).legende);
3045:
3046: liberation(s_etat_processus, (*s_etat_processus)
3047: .parametres_courbes_de_niveau);
3048:
3049: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
3050: {
3051: liberation(s_etat_processus,
3052: (*s_etat_processus).corps_interruptions[i]);
3053:
3054: l_element_courant = (*s_etat_processus)
3055: .pile_origine_interruptions[i];
3056:
3057: while(l_element_courant != NULL)
3058: {
3059: l_element_suivant = (*((struct_liste_chainee *)
3060: l_element_courant)).suivant;
3061:
3062: liberation(s_etat_processus,
3063: (*((struct_liste_chainee *)
3064: l_element_courant)).donnee);
3065: free(l_element_courant);
3066:
3067: l_element_courant = l_element_suivant;
3068: }
3069: }
3070:
3071: if ((*s_etat_processus).instruction_derniere_erreur
3072: != NULL)
3073: {
3074: free((*s_etat_processus).instruction_derniere_erreur);
3075: (*s_etat_processus).instruction_derniere_erreur = NULL;
3076: }
3077:
3078: /*
3079: * Le pointeur s_etat_processus.nom_fichier_source est
3080: * alloué par le système. Il ne faut donc pas
3081: * le libérer...
3082: */
3083:
3084: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
3085: {
3086: liberation(s_etat_processus,
3087: (*s_etat_processus).s_liste_variables[i].objet);
3088: free((*s_etat_processus).s_liste_variables[i].nom);
3089: }
3090:
3091: free((*s_etat_processus).s_liste_variables);
3092:
3093: for(i = 0; i < (*s_etat_processus)
3094: .nombre_variables_statiques; i++)
3095: {
3096: liberation(s_etat_processus, (*s_etat_processus)
3097: .s_liste_variables_statiques[i].objet);
3098: free((*s_etat_processus)
3099: .s_liste_variables_statiques[i].nom);
3100: }
3101:
3102: free((*s_etat_processus).s_liste_variables_statiques);
3103:
3104: for(i = 0; i < (*((*s_etat_processus)
3105: .s_liste_variables_partagees)).nombre_variables;
3106: i++)
3107: {
3108: liberation(s_etat_processus, (*((*s_etat_processus)
3109: .s_liste_variables_partagees)).table[i].objet);
3110: free((*((*s_etat_processus)
3111: .s_liste_variables_partagees)).table[i].nom);
3112: }
3113:
3114: free((struct_variable_partagee *)
3115: (*((*s_etat_processus).s_liste_variables_partagees))
3116: .table);
3117:
3118: /*
3119: * Si resultats est non nul, rplinit a été appelé
3120: * depuis rpl() [librpl] et non main().
3121: * On copie alors le contenu de la * pile dans un
3122: * tableau **resultats dont le pointeur de base a
3123: * été alloué dans rpl().
3124: */
3125:
3126: if (resultats != NULL)
3127: {
3128: if ((*resultats) != NULL)
3129: {
3130: free((*resultats));
3131:
3132: if (((*resultats) = malloc(((*s_etat_processus)
3133: .hauteur_pile_operationnelle + 1)
3134: * sizeof(unsigned char **))) != NULL)
3135: {
3136: (*resultats)[(*s_etat_processus)
3137: .hauteur_pile_operationnelle] = NULL;
3138: l_element_courant = (void *) (*s_etat_processus)
3139: .l_base_pile;
3140:
3141: for(i = 0; i < (*s_etat_processus)
3142: .hauteur_pile_operationnelle; i++)
3143: {
3144: if (l_element_courant != NULL)
3145: {
3146: (*resultats)[i] =
3147: formateur(s_etat_processus,
3148: 0, (*((struct_liste_chainee *)
3149: l_element_courant)).donnee);
3150:
3151: if ((*resultats)[i] == NULL)
3152: {
3153: i = (*s_etat_processus).
3154: hauteur_pile_operationnelle;
3155: }
3156: else
3157: {
3158: l_element_suivant =
3159: (*((struct_liste_chainee *)
3160: l_element_courant)).suivant;
3161: }
3162: }
3163: }
3164: }
3165: else
3166: {
3167: (*resultats) = NULL;
3168: erreur = d_es_allocation_memoire;
3169: }
3170: }
3171: }
3172:
3173: l_element_courant = (void *) (*s_etat_processus)
3174: .l_base_pile;
3175: while(l_element_courant != NULL)
3176: {
3177: l_element_suivant = (*((struct_liste_chainee *)
3178: l_element_courant)).suivant;
3179:
3180: liberation(s_etat_processus,
3181: (*((struct_liste_chainee *)
3182: l_element_courant)).donnee);
3183: free((struct_liste_chainee *) l_element_courant);
3184:
3185: l_element_courant = l_element_suivant;
3186: }
3187:
3188: l_element_courant = (void *) (*s_etat_processus)
3189: .l_base_pile_contextes;
3190: while(l_element_courant != NULL)
3191: {
3192: l_element_suivant = (*((struct_liste_chainee *)
3193: l_element_courant)).suivant;
3194:
3195: liberation(s_etat_processus,
3196: (*((struct_liste_chainee *)
3197: l_element_courant)).donnee);
3198: free((struct_liste_chainee *) l_element_courant);
3199:
3200: l_element_courant = l_element_suivant;
3201: }
3202:
3203: l_element_courant = (void *) (*s_etat_processus)
3204: .l_base_pile_taille_contextes;
3205: while(l_element_courant != NULL)
3206: {
3207: l_element_suivant = (*((struct_liste_chainee *)
3208: l_element_courant)).suivant;
3209:
3210: liberation(s_etat_processus,
3211: (*((struct_liste_chainee *)
3212: l_element_courant)).donnee);
3213: free((struct_liste_chainee *) l_element_courant);
3214:
3215: l_element_courant = l_element_suivant;
3216: }
3217:
3218: for(i = 0; i < (*s_etat_processus)
3219: .nombre_instructions_externes; i++)
3220: {
3221: free((*s_etat_processus).s_instructions_externes[i]
3222: .nom);
3223: free((*s_etat_processus).s_instructions_externes[i]
3224: .nom_bibliotheque);
3225: }
3226:
3227: if ((*s_etat_processus).nombre_instructions_externes != 0)
3228: {
3229: free((*s_etat_processus).s_instructions_externes);
3230: }
3231:
3232: l_element_courant = (void *) (*s_etat_processus)
3233: .s_bibliotheques;
3234:
3235: while(l_element_courant != NULL)
3236: {
3237: l_element_suivant = (*((struct_liste_chainee *)
3238: l_element_courant)).suivant;
3239:
3240: free((*((struct_bibliotheque *)
3241: (*((struct_liste_chainee *)
3242: l_element_courant)).donnee)).nom);
3243: dlclose((*((struct_bibliotheque *)
3244: (*((struct_liste_chainee *)
3245: l_element_courant)).donnee)).descripteur);
3246: free((*((struct_liste_chainee *) l_element_courant))
3247: .donnee);
3248: free(l_element_courant);
3249:
3250: l_element_courant = l_element_suivant;
3251: }
3252:
3253: l_element_courant = (void *) (*s_etat_processus)
3254: .l_base_pile_last;
3255: while(l_element_courant != NULL)
3256: {
3257: l_element_suivant = (*((struct_liste_chainee *)
3258: l_element_courant)).suivant;
3259:
3260: liberation(s_etat_processus,
3261: (*((struct_liste_chainee *)
3262: l_element_courant)).donnee);
3263: free((struct_liste_chainee *) l_element_courant);
3264:
3265: l_element_courant = l_element_suivant;
3266: }
3267:
3268: l_element_courant = (void *) (*s_etat_processus)
3269: .l_base_pile_systeme;
3270: while(l_element_courant != NULL)
3271: {
3272: l_element_suivant = (*((struct_liste_pile_systeme *)
3273: l_element_courant)).suivant;
3274:
3275: liberation(s_etat_processus,
3276: (*((struct_liste_pile_systeme *)
3277: l_element_courant)).indice_boucle);
3278: liberation(s_etat_processus,
3279: (*((struct_liste_pile_systeme *)
3280: l_element_courant)).limite_indice_boucle);
3281: liberation(s_etat_processus,
3282: (*((struct_liste_pile_systeme *)
3283: l_element_courant)).objet_de_test);
3284:
3285: if ((*((struct_liste_pile_systeme *)
3286: l_element_courant)).nom_variable != NULL)
3287: {
3288: free((*((struct_liste_pile_systeme *)
3289: l_element_courant)).nom_variable);
3290: }
3291:
3292: free((struct_liste_pile_systeme *)
3293: l_element_courant);
3294:
3295: l_element_courant = l_element_suivant;
3296: }
3297:
3298: l_element_courant = (void *)
3299: (*s_etat_processus).s_fichiers;
3300: while(l_element_courant != NULL)
3301: {
3302: l_element_suivant = (*((struct_liste_chainee *)
3303: l_element_courant)).suivant;
3304:
3305: fclose((*((struct_descripteur_fichier *)
3306: (*((struct_liste_chainee *)
3307: l_element_courant)).donnee))
3308: .descripteur_c);
3309:
3310: if ((*((struct_descripteur_fichier *)
3311: (*((struct_liste_chainee *)
3312: l_element_courant)).donnee)).type != 'C')
3313: {
3314: sqlite3_close((*((struct_descripteur_fichier *)
3315: (*((struct_liste_chainee *)
3316: l_element_courant)).donnee))
3317: .descripteur_sqlite);
3318: }
3319:
3320: if ((*((struct_descripteur_fichier *)
3321: (*((struct_liste_chainee *)
3322: l_element_courant)).donnee))
3323: .effacement == 'Y')
3324: {
3325: unlink((*((struct_descripteur_fichier *)
3326: (*((struct_liste_chainee *)
3327: l_element_courant)).donnee))
3328: .nom);
3329: }
3330:
3331: free((*((struct_descripteur_fichier *)
3332: (*((struct_liste_chainee *)
3333: l_element_courant)).donnee)).nom);
3334: free((struct_descripteur_fichier *)
3335: (*((struct_liste_chainee *)
3336: l_element_courant)).donnee);
3337: free(l_element_courant);
3338:
3339: l_element_courant = l_element_suivant;
3340: }
3341:
3342: l_element_courant = (void *)
3343: (*s_etat_processus).s_sockets;
3344: while(l_element_courant != NULL)
3345: {
3346: l_element_suivant = (*((struct_liste_chainee *)
3347: l_element_courant)).suivant;
3348:
3349: if ((*((struct_socket *)
3350: (*(*((struct_liste_chainee *)
3351: l_element_courant)).donnee).objet))
3352: .socket_connectee == d_vrai)
3353: {
3354: shutdown((*((struct_socket *)
3355: (*(*((struct_liste_chainee *)
3356: l_element_courant)).donnee).objet))
3357: .socket, SHUT_RDWR);
3358: }
3359:
3360: close((*((struct_socket *)
3361: (*(*((struct_liste_chainee *)
3362: l_element_courant)).donnee).objet)).socket);
3363:
3364: if ((*((struct_socket *) (*(*((struct_liste_chainee *)
3365: l_element_courant)).donnee).objet)).effacement
3366: == 'Y')
3367: {
3368: unlink((*((struct_socket *)
3369: (*(*((struct_liste_chainee *)
3370: l_element_courant)).donnee).objet))
3371: .adresse);
3372: }
3373:
3374: liberation(s_etat_processus,
3375: (*((struct_liste_chainee *)
3376: l_element_courant)).donnee);
3377: free(l_element_courant);
3378:
3379: l_element_courant = l_element_suivant;
3380: }
3381:
3382: l_element_courant = (void *)
3383: (*s_etat_processus).s_connecteurs_sql;
3384: while(l_element_courant != NULL)
3385: {
3386: l_element_suivant = (*((struct_liste_chainee *)
3387: l_element_courant)).suivant;
3388:
3389: sqlclose((*((struct_liste_chainee *)
3390: l_element_courant)).donnee);
3391: liberation(s_etat_processus,
3392: (*((struct_liste_chainee *)
3393: l_element_courant)).donnee);
3394: free(l_element_courant);
3395:
3396: l_element_courant = l_element_suivant;
3397: }
3398:
3399: free((*s_etat_processus).chemin_fichiers_temporaires);
3400:
3401: l_element_courant = (*s_etat_processus).s_marques;
3402: while(l_element_courant != NULL)
3403: {
3404: free((*((struct_marque *) l_element_courant)).label);
3405: free((*((struct_marque *) l_element_courant)).position);
3406: l_element_suivant = (*((struct_marque *)
3407: l_element_courant)).suivant;
3408: free(l_element_courant);
3409: l_element_courant = l_element_suivant;
3410: }
3411: }
3412: else
3413: {
3414: erreur = d_es_allocation_memoire;
3415:
3416: if (test_cfsf(s_etat_processus, 51) == d_faux)
3417: {
3418: printf("%s", ds_beep);
3419: }
3420:
3421: if ((*s_etat_processus).langue == 'F')
3422: {
3423: printf("+++Système : Mémoire insuffisante\n");
3424: }
3425: else
3426: {
3427: printf("+++System : Not enough memory\n");
3428: }
3429: }
3430: }
3431:
3432: liberation_allocateur(s_etat_processus);
3433: }
3434:
3435: if (traitement_fichier_temporaire == 'Y')
3436: {
3437: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
3438: {
3439: return(EXIT_FAILURE);
3440: }
3441:
3442: free(nom_fichier_temporaire);
3443: }
3444:
3445: if ((*s_etat_processus).profilage == d_vrai)
3446: {
3447: ecriture_profil(s_etat_processus);
3448: liberation_profil(s_etat_processus);
3449: }
3450: }
3451:
3452: # ifndef Cygwin
3453: free((*s_etat_processus).pile_signal.ss_sp);
3454: # endif
3455:
3456: closelog();
3457:
3458: pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
3459: pthread_mutex_destroy(&((*((*s_etat_processus).s_liste_variables_partagees))
3460: .mutex));
3461:
3462: retrait_thread(s_etat_processus);
3463:
3464: pthread_mutex_destroy(&((*s_etat_processus).mutex));
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_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
3471: # endif
3472:
3473: free((*s_etat_processus).localisation);
3474: free(s_etat_processus);
3475:
3476: # ifndef SEMAPHORES_NOMMES
3477: sem_destroy(&semaphore_liste_threads);
3478: # else
3479: sem_destroy2(semaphore_liste_threads, sem_liste_threads);
3480: # endif
3481: # ifndef SEMAPHORES_NOMMES
3482: sem_post(&semaphore_gestionnaires_signaux);
3483: sem_destroy(&semaphore_gestionnaires_signaux);
3484: sem_destroy(&semaphore_gestionnaires_signaux_atomique);
3485: # else
3486: sem_post(semaphore_gestionnaires_signaux);
3487: sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
3488: sem_destroy2(semaphore_gestionnaires_signaux_atomique,
3489: sem_gestionnaires_signaux_atomique);
3490: # endif
3491:
3492: # ifdef DEBUG_MEMOIRE
3493: debug_memoire_verification(s_etat_processus);
3494: # endif
3495:
3496: return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);
3497: }
3498:
3499:
3500: void
3501: informations(struct_processus *s_etat_processus)
3502: {
3503: printf("\n");
3504:
3505: if ((*s_etat_processus).langue == 'F')
3506: {
3507: printf(" rpl [-options] [programme]\n");
3508: printf(" -a : analyse du code\n");
3509: printf(" -A : paramètres passés au programme principal\n");
3510: printf(" -c : génération de fichier de débogage (rpl-core)\n");
3511: printf(" -d : option de déverminage interne\n");
3512: printf(" -D : lancement d'un daemon\n");
3513: printf(" -h : aide sur la ligne de commande\n");
3514: printf(" -i : fonctionnement interactif\n");
3515: printf(" -l : licence d'utilisation\n");
3516: printf(" -n : ignorance du signal HUP\n");
3517: printf(" -p : précompilation du script avant exécution\n");
3518: printf(" -P : profilage\n");
3519: printf(" -s : empêchement de l'ouverture de l'écran initial\n");
3520: printf(" -S : exécution du script passé en ligne de commande\n");
3521: printf(" -t : trace\n");
3522: printf(" -v : version\n");
3523: }
3524: else
3525: {
3526: printf(" rpl [-options] [program]\n");
3527: printf(" -a : analyzes program\n");
3528: printf(" -A : sends parameters to main program\n");
3529: printf(" -c : allows creation of a rpl-core file, providing a way"
3530: "\n"
3531: " to debug a program\n");
3532: printf(" -d : internal debug process\n");
3533: printf(" -D : starts in daemon mode\n");
3534: printf(" -h : shows a summary of available options\n");
3535: printf(" -i : runs the RPL/2 sequencer in interactive mode\n");
3536: printf(" -l : prints the user licence of the software\n");
3537: printf(" -n : ignores HUP signal\n");
3538: printf(" -p : precompiles script\n");
3539: printf(" -P : computes profile data\n");
3540: printf(" -s : disables splash screen\n");
3541: printf(" -S : executes script written in command line\n");
3542: printf(" -t : enables tracing mode\n");
3543: printf(" -v : prints the version number\n");
3544: }
3545:
3546: printf("\n");
3547:
3548: return;
3549: }
3550:
3551: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>