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