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