1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.22
4: Copyright (C) 1989-2015 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Boucle principale de l'interprète RPL/2
29: ================================================================================
30: Entrées : structure sur l'état du processus
31: --------------------------------------------------------------------------------
32: Sorties : néant
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: logical1
39: sequenceur(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42:
43: struct_objet *s_objet;
44: struct_objet *s_objet_evaluation;
45: struct_objet *s_sous_objet;
46:
47: integer8 niveau;
48: integer8 position_courante;
49:
50: logical1 drapeau_appel_definition;
51: logical1 drapeau_fin;
52: logical1 drapeau_then;
53: logical1 erreur;
54: logical1 presence_compteur;
55:
56: static logical1 completion_valide = d_faux;
57:
58: struct sigaction action;
59: struct sigaction action_defaut;
60: struct sigaction action_defaut2;
61:
62: unsigned char *instruction_majuscule;
63: unsigned char *ligne;
64: unsigned char *message;
65: unsigned char *registre;
66: unsigned char *tampon;
67: unsigned char *t_ligne;
68:
69: Keymap ancien_keymap;
70: Keymap nouveau_keymap;
71:
72: (*s_etat_processus).retour_routine_evaluation = 'N';
73:
74: if ((*s_etat_processus).debug == d_vrai)
75: if (((*s_etat_processus).type_debug &
76: d_debug_appels_fonctions) != 0)
77: {
78: if ((*s_etat_processus).niveau_recursivite != 0)
79: {
80: if ((*s_etat_processus).langue == 'F')
81: {
82: printf("[%d] Exécution récursive de niveau %lld\n",
83: (int) getpid(), (*s_etat_processus).niveau_recursivite);
84: }
85: else
86: {
87: printf("[%d] %lld level recursive execution\n",
88: (int) getpid(), (*s_etat_processus).niveau_recursivite);
89: }
90: }
91: else
92: {
93: if ((*s_etat_processus).langue == 'F')
94: {
95: printf("[%d] Exécution\n", (int) getpid());
96: }
97: else
98: {
99: printf("[%d] Execution\n", (int) getpid());
100: }
101: }
102:
103: fflush(stdout);
104: }
105:
106: /*
107: --------------------------------------------------------------------------------
108: Boucle de l'interprète RPL/2
109: On boucle tant qu'on n'a pas une bonne raison de sortir...
110: --------------------------------------------------------------------------------
111: */
112:
113: do
114: {
115: drapeau_appel_definition = d_faux;
116:
117: /*
118: --------------------------------------------------------------------------------
119: Recherche de l'instruction suivante dans les définitions chaînées
120: --------------------------------------------------------------------------------
121: */
122:
123: if ((erreur = recherche_instruction_suivante(s_etat_processus))
124: == d_erreur)
125: {
126: return(d_erreur);
127: }
128:
129: if (((*s_etat_processus).debug_programme == d_vrai) &&
130: ((*s_etat_processus).niveau_recursivite == 0))
131: {
132: /*
133: * Traitement de la commande HALT (debug)
134: */
135:
136: action.sa_handler = SIG_IGN;
137: action.sa_flags = SA_NODEFER | SA_ONSTACK;
138:
139: (*s_etat_processus).execution_pas_suivant = d_faux;
140: (*s_etat_processus).traitement_instruction_halt = d_vrai;
141:
142: if (completion_valide == d_faux)
143: {
144: initialisation_completion();
145: completion_valide = d_vrai;
146: }
147:
148: while((*s_etat_processus).execution_pas_suivant == d_faux)
149: {
150: if ((*s_etat_processus).hauteur_pile_operationnelle != 0)
151: {
152: fprintf(stdout, "\n");
153: }
154:
155: affichage_pile(s_etat_processus, (*s_etat_processus)
156: .l_base_pile, 1);
157:
158: if ((*s_etat_processus).mode_interactif == 'N')
159: {
160: printf("[%d] Instruction : %s\n", (int) getpid(),
161: (*s_etat_processus).instruction_courante);
162: fflush(stdout);
163: }
164:
165: if (sigaction(SIGINT, &action, &action_defaut) != 0)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_signal;
168: return(d_erreur);
169: }
170:
171: if (sigaction(SIGTSTP, &action, &action_defaut2) != 0)
172: {
173: (*s_etat_processus).erreur_systeme = d_es_signal;
174: return(d_erreur);
175: }
176:
177: (*s_etat_processus).var_volatile_requete_arret = 0;
178: (*s_etat_processus).var_volatile_requete_arret2 = 0;
179:
180: flockfile(stdin);
181: flockfile(stdout);
182:
183: ancien_keymap = rl_get_keymap();
184: nouveau_keymap = rl_copy_keymap(ancien_keymap);
185: rl_set_keymap(nouveau_keymap);
186:
187: rl_bind_key(NEWLINE, readline_analyse_syntaxique);
188: rl_bind_key(RETURN, readline_analyse_syntaxique);
189: rl_bind_key(CTRL('g'), readline_effacement);
190: rl_done = 0;
191:
192: ligne = readline("RPL/2> ");
193:
194: rl_set_keymap(ancien_keymap);
195: rl_free(nouveau_keymap);
196:
197: funlockfile(stdin);
198: funlockfile(stdout);
199:
200: if (ligne != NULL)
201: {
202: if ((t_ligne = transliteration(s_etat_processus, ligne,
203: (*s_etat_processus).localisation, d_locale))
204: == NULL)
205: {
206: free((*s_etat_processus).instruction_courante);
207: return(d_erreur);
208: }
209:
210: free(ligne);
211: ligne = t_ligne;
212:
213: if ((ligne = compactage(s_etat_processus, ligne)) == NULL)
214: {
215: (*s_etat_processus).erreur_systeme =
216: d_es_allocation_memoire;
217: return(d_erreur);
218: }
219: }
220:
221: if (sigaction(SIGINT, &action_defaut, NULL) != 0)
222: {
223: (*s_etat_processus).erreur_systeme = d_es_signal;
224: return(d_erreur);
225: }
226:
227: if (sigaction(SIGTSTP, &action_defaut2, NULL) != 0)
228: {
229: (*s_etat_processus).erreur_systeme = d_es_signal;
230: return(d_erreur);
231: }
232:
233: if (ligne == NULL)
234: {
235: if ((ligne = (unsigned char *) malloc(6 *
236: sizeof(unsigned char))) == NULL)
237: {
238: (*s_etat_processus).erreur_systeme =
239: d_es_allocation_memoire;
240: return(d_erreur);
241: }
242:
243: sprintf(ligne, "abort");
244: fprintf(stdout, "%s\n", ligne);
245: }
246: else if (((*ligne) == d_code_fin_chaine) &&
247: ((*s_etat_processus).l_base_pile != NULL))
248: {
249: free(ligne);
250:
251: if ((ligne = (unsigned char *) malloc(4 *
252: sizeof(unsigned char))) == NULL)
253: {
254: (*s_etat_processus).erreur_systeme =
255: d_es_allocation_memoire;
256: return(d_erreur);
257: }
258:
259: sprintf(ligne, "dup");
260: }
261:
262: if ((*s_etat_processus).var_volatile_requete_arret != 0)
263: {
264: free(ligne);
265: (*s_etat_processus).requete_arret = 'Y';
266: break;
267: }
268:
269: add_history(ligne);
270: stifle_history(ds_longueur_historique);
271:
272: position_courante = (*s_etat_processus).position_courante;
273: tampon = (*s_etat_processus).definitions_chainees;
274: registre = (*s_etat_processus).instruction_courante;
275: (*s_etat_processus).definitions_chainees = ligne;
276:
277: if (analyse_syntaxique(s_etat_processus) == d_absence_erreur)
278: {
279: (*s_etat_processus).instruction_courante = registre;
280: (*s_etat_processus).position_courante = position_courante;
281: (*s_etat_processus).definitions_chainees = tampon;
282:
283: if ((tampon = (unsigned char *) malloc((strlen(ligne) + 7) *
284: sizeof(unsigned char))) == NULL)
285: {
286: (*s_etat_processus).erreur_systeme =
287: d_es_allocation_memoire;
288: return(d_erreur);
289: }
290:
291: sprintf(tampon, "<< %s >>", ligne);
292:
293: free(ligne);
294: ligne = tampon;
295:
296: tampon = (*s_etat_processus).instruction_courante;
297: (*s_etat_processus).instruction_courante = ligne;
298:
299: (*s_etat_processus).type_en_cours = NON;
300: recherche_type(s_etat_processus);
301:
302: (*s_etat_processus).instruction_courante = tampon;
303:
304: if ((((*s_etat_processus).erreur_execution != d_ex) ||
305: ((*s_etat_processus).erreur_systeme != d_es)) &&
306: ((*s_etat_processus).invalidation_message_erreur
307: == d_faux))
308: {
309: if ((*s_etat_processus).erreur_execution != d_ex)
310: {
311: (*s_etat_processus).erreur_scrutation = d_vrai;
312: }
313:
314: if (test_cfsf(s_etat_processus, 51) == d_faux)
315: {
316: printf("%s", ds_beep);
317: }
318:
319: if ((message = messages(s_etat_processus)) == NULL)
320: {
321: free((*s_etat_processus).instruction_courante);
322: return(d_erreur);
323: }
324:
325: printf("%s [%d]\n", message, (int) getpid());
326:
327: free(message);
328:
329: (*s_etat_processus).erreur_execution = d_ex;
330:
331: if ((*s_etat_processus).erreur_systeme != d_es)
332: {
333: return(d_erreur);
334: }
335: }
336: else
337: {
338: position_courante =
339: (*s_etat_processus).position_courante;
340: empilement_pile_systeme(s_etat_processus);
341:
342: if ((*s_etat_processus).erreur_systeme != d_es)
343: {
344: return(d_erreur);
345: }
346:
347: (*(*s_etat_processus).l_base_pile_systeme)
348: .retour_definition = 'Y';
349:
350: if (depilement(s_etat_processus, &((*s_etat_processus)
351: .l_base_pile), &s_objet) == d_erreur)
352: {
353: if (test_cfsf(s_etat_processus, 51) == d_faux)
354: {
355: printf("%s", ds_beep);
356: }
357:
358: if ((*s_etat_processus).langue == 'F')
359: {
360: printf("+++Erreur : Défaut d'argument\n");
361: }
362: else
363: {
364: printf("+++Error : Too few arguments\n");
365: }
366:
367: depilement_pile_systeme(s_etat_processus);
368:
369: if ((*s_etat_processus).erreur_systeme != d_es)
370: {
371: return(d_erreur);
372: }
373:
374: fflush(stdout);
375: }
376: else if (evaluation(s_etat_processus, s_objet, 'I') ==
377: d_erreur)
378: {
379: if ((*s_etat_processus).erreur_systeme != d_es)
380: {
381: if (test_cfsf(s_etat_processus, 51) == d_faux)
382: {
383: printf("%s", ds_beep);
384: }
385:
386: if ((message = messages(s_etat_processus))
387: == NULL)
388: {
389: free((*s_etat_processus)
390: .instruction_courante);
391: return(d_erreur);
392: }
393:
394: printf("%s [%d]\n", message, (int) getpid());
395:
396: free(message);
397: free((*s_etat_processus).instruction_courante);
398: return(d_erreur);
399: }
400: else if ((*s_etat_processus)
401: .invalidation_message_erreur == d_faux)
402: {
403: (*s_etat_processus).erreur_execution =
404: (*s_etat_processus)
405: .derniere_erreur_evaluation;
406:
407: if (test_cfsf(s_etat_processus, 51) == d_faux)
408: {
409: printf("%s", ds_beep);
410: }
411:
412: if ((message = messages(s_etat_processus))
413: == NULL)
414: {
415: free((*s_etat_processus)
416: .instruction_courante);
417: return(d_erreur);
418: }
419:
420: printf("%s [%d]\n", message, (int) getpid());
421: free(message);
422:
423: if (test_cfsf(s_etat_processus, 31) == d_vrai)
424: {
425: l_element_courant = (*s_etat_processus)
426: .l_base_pile_last;
427:
428: while(l_element_courant != NULL)
429: {
430: if ((s_sous_objet = copie_objet(
431: s_etat_processus,
432: (*l_element_courant).donnee,
433: 'P')) == NULL)
434: {
435: (*s_etat_processus).erreur_systeme =
436: d_es_allocation_memoire;
437: return(d_erreur);
438: }
439:
440: if (empilement(s_etat_processus,
441: &((*s_etat_processus)
442: .l_base_pile),
443: s_sous_objet) == d_erreur)
444: {
445: return(d_erreur);
446: }
447:
448: l_element_courant = (*l_element_courant)
449: .suivant;
450: }
451: }
452:
453: (*s_etat_processus).erreur_execution = d_ex;
454: (*s_etat_processus).exception = d_ep;
455: }
456:
457: liberation(s_etat_processus, s_objet);
458: }
459: else
460: {
461: liberation(s_etat_processus, s_objet);
462: }
463:
464: (*s_etat_processus).position_courante =
465: position_courante;
466: }
467: }
468: else if ((*s_etat_processus).invalidation_message_erreur
469: == d_faux)
470: {
471: (*s_etat_processus).instruction_courante = registre;
472: (*s_etat_processus).position_courante = position_courante;
473: (*s_etat_processus).definitions_chainees = tampon;
474:
475: if (test_cfsf(s_etat_processus, 51) == d_faux)
476: {
477: printf("%s", ds_beep);
478: }
479:
480: if ((message = messages(s_etat_processus)) == NULL)
481: {
482: free((*s_etat_processus).instruction_courante);
483: free(ligne);
484: return(d_erreur);
485: }
486:
487: free(message);
488:
489: if ((*s_etat_processus).langue == 'F')
490: {
491: printf("+++Erreur : Erreur de syntaxe\n");
492: }
493: else
494: {
495: printf("+++Error : Syntax error\n");
496: }
497:
498: fflush(stdout);
499: }
500:
501: free(ligne);
502: }
503:
504: (*s_etat_processus).traitement_instruction_halt = d_faux;
505: }
506:
507: if ((*s_etat_processus).debug == d_vrai)
508: if (((*s_etat_processus).type_debug &
509: d_debug_fonctions_intrinseques) != 0)
510: {
511: if ((*s_etat_processus).langue == 'F')
512: {
513: printf("[%d] Instruction %s\n",
514: (int) getpid(),
515: (*s_etat_processus).instruction_courante);
516: }
517: else
518: {
519: printf("[%d] %s instruction\n",
520: (int) getpid(),
521: (*s_etat_processus).instruction_courante);
522: }
523:
524: fflush(stdout);
525: }
526:
527: /*
528: --------------------------------------------------------------------------------
529: Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le
530: cas contraire, l'interprète renvoie un message d'erreur et s'interrompt.
531: --------------------------------------------------------------------------------
532: */
533:
534: if (erreur == d_absence_erreur)
535: {
536:
537: /*
538: --------------------------------------------------------------------------------
539: Scrutation des mots clef du langage RPL/2 et exécution le cas échéant
540: de l'action associée.
541: --------------------------------------------------------------------------------
542: */
543:
544: analyse(s_etat_processus, NULL);
545:
546: if ((*s_etat_processus).traitement_cycle_exit != 'N')
547: {
548: switch((*s_etat_processus).traitement_cycle_exit)
549: {
550: case 'C' :
551: {
552: instruction_cycle(s_etat_processus);
553: break;
554: }
555:
556: case 'E' :
557: {
558: instruction_exit(s_etat_processus);
559: break;
560: }
561: }
562: }
563:
564: if ((*s_etat_processus).instruction_valide == 'N')
565: {
566:
567: /*
568: --------------------------------------------------------------------------------
569: L'instruction ne correspond pas à l'un des mots clef du langage RPL/2.
570: --------------------------------------------------------------------------------
571: */
572:
573: if ((recherche_variable(s_etat_processus,
574: (*s_etat_processus).instruction_courante) ==
575: d_vrai) && ((*s_etat_processus)
576: .autorisation_evaluation_nom == 'Y'))
577: {
578: if ((*(*s_etat_processus).pointeur_variable_courante)
579: .objet == NULL)
580: {
581:
582: /*
583: --------------------------------------------------------------------------------
584: L'instruction est une variable partagée
585: --------------------------------------------------------------------------------
586: */
587:
588: if (recherche_variable_partagee(s_etat_processus,
589: (*(*s_etat_processus)
590: .pointeur_variable_courante).nom,
591: (*(*s_etat_processus)
592: .pointeur_variable_courante).variable_partagee,
593: 'P') != NULL)
594: {
595: // La variable existe.
596:
597: if ((*s_etat_processus).debug == d_vrai)
598: if (((*s_etat_processus).type_debug &
599: d_debug_variables) != 0)
600: {
601: if ((*s_etat_processus).langue == 'F')
602: {
603: printf("[%d] Évaluation de la variable "
604: "partagée %s de type %d\n",
605: (int) getpid(), (*s_etat_processus)
606: .instruction_courante,
607: (*(*(*s_etat_processus)
608: .pointeur_variable_partagee_courante)
609: .objet).type);
610: }
611: else
612: {
613: printf("[%d] Pushing %s as %d type shared "
614: "variable\n", (int) getpid(),
615: (*s_etat_processus)
616: .instruction_courante,
617: (*(*(*s_etat_processus)
618: .pointeur_variable_partagee_courante)
619: .objet).type);
620: }
621:
622: fflush(stdout);
623: }
624:
625: if ((s_objet = copie_objet(s_etat_processus,
626: (*(*s_etat_processus)
627: .pointeur_variable_partagee_courante)
628: .objet, 'P')) == NULL)
629: {
630: (*s_etat_processus).erreur_systeme =
631: d_es_allocation_memoire;
632: return(d_erreur);
633: }
634:
635: if (pthread_mutex_unlock(&((*(*s_etat_processus)
636: .pointeur_variable_partagee_courante)
637: .mutex)) != 0)
638: {
639: (*s_etat_processus).erreur_systeme =
640: d_es_processus;
641: return(d_erreur);
642: }
643:
644: if (evaluation(s_etat_processus, s_objet, 'E')
645: == d_erreur)
646: {
647: liberation(s_etat_processus, s_objet);
648: return(d_erreur);
649: }
650:
651: liberation(s_etat_processus, s_objet);
652: }
653: else
654: {
655: // La variable n'existe plus.
656: if ((*s_etat_processus).debug == d_vrai)
657: if (((*s_etat_processus).type_debug &
658: d_debug_variables) != 0)
659: {
660: if ((*s_etat_processus).langue == 'F')
661: {
662: printf("[%d] Tentative d'accès à la "
663: "variable partagée non définie %s\n",
664: (int) getpid(), (*s_etat_processus)
665: .instruction_courante);
666: }
667: else
668: {
669: printf("[%d] Trying to access to undefined "
670: "shared variable %s\n",
671: (int) getpid(),
672: (*s_etat_processus)
673: .instruction_courante);
674: }
675:
676: fflush(stdout);
677: }
678: }
679: }
680:
681: /*
682: --------------------------------------------------------------------------------
683: L'instruction est une variable automatique (évaluation lors de l'empilement).
684: --------------------------------------------------------------------------------
685: */
686:
687: else if ((*(*(*s_etat_processus).pointeur_variable_courante)
688: .objet).type == ADR)
689: {
690:
691: /*
692: --------------------------------------------------------------------------------
693: L'instruction est une variable de type 'adresse' pointant sur une
694: définition. Un branchement est effectué à cette adresse.
695: --------------------------------------------------------------------------------
696: */
697:
698: if ((*s_etat_processus).debug == d_vrai)
699: if (((*s_etat_processus).type_debug &
700: d_debug_appels_fonctions) != 0)
701: {
702: if ((*s_etat_processus).langue == 'F')
703: {
704: printf("[%d] Branchement à la"
705: " définition %s\n", (int) getpid(),
706: (*s_etat_processus)
707: .instruction_courante);
708: }
709: else
710: {
711: printf("[%d] Execution : "
712: "Branching at %s definition\n",
713: (int) getpid(), (*s_etat_processus)
714: .instruction_courante);
715: }
716:
717: fflush(stdout);
718: }
719:
720: (*s_etat_processus).autorisation_empilement_programme =
721: 'N';
722:
723: empilement_pile_systeme(s_etat_processus);
724:
725: if ((*s_etat_processus).erreur_systeme != d_es)
726: {
727: erreur = d_erreur;
728: }
729: else
730: {
731: if ((*s_etat_processus).profilage == d_vrai)
732: {
733: profilage(s_etat_processus,
734: (*s_etat_processus)
735: .instruction_courante);
736:
737: if ((*s_etat_processus).erreur_systeme != d_es)
738: {
739: return(d_erreur);
740: }
741: }
742:
743: (*(*s_etat_processus).l_base_pile_systeme)
744: .adresse_retour = (*s_etat_processus)
745: .position_courante;
746:
747: (*(*s_etat_processus).l_base_pile_systeme)
748: .retour_definition = 'Y';
749:
750: (*(*s_etat_processus).l_base_pile_systeme)
751: .niveau_courant = (*s_etat_processus)
752: .niveau_courant;
753:
754: (*s_etat_processus).position_courante =
755: (*((integer8 *)
756: ((*(*(*s_etat_processus)
757: .pointeur_variable_courante)
758: .objet).objet)));
759:
760: drapeau_appel_definition = d_vrai;
761: }
762: }
763: else
764: {
765: if ((*s_etat_processus).debug == d_vrai)
766: if (((*s_etat_processus).type_debug &
767: d_debug_variables) != 0)
768: {
769: if ((*s_etat_processus).langue == 'F')
770: {
771: printf("[%d] Évaluation de la variable "
772: "%s de type %d\n",
773: (int) getpid(),
774: (*s_etat_processus)
775: .instruction_courante,
776: (*(*(*s_etat_processus)
777: .pointeur_variable_courante).objet)
778: .type);
779: }
780: else
781: {
782: printf("[%d] Pushing %s as %d type variable "
783: "\n", (int) getpid(),
784: (*s_etat_processus)
785: .instruction_courante,
786: (*(*(*s_etat_processus)
787: .pointeur_variable_courante).objet)
788: .type);
789: }
790:
791: fflush(stdout);
792: }
793:
794: if ((s_objet = copie_objet(s_etat_processus,
795: (*(*s_etat_processus)
796: .pointeur_variable_courante).objet, 'P'))
797: == NULL)
798: {
799: (*s_etat_processus).erreur_systeme =
800: d_es_allocation_memoire;
801: return(d_erreur);
802: }
803:
804: if (evaluation(s_etat_processus, s_objet, 'E')
805: == d_erreur)
806: {
807: liberation(s_etat_processus, s_objet);
808: return(d_erreur);
809: }
810:
811: liberation(s_etat_processus, s_objet);
812: }
813: }
814: else
815: {
816:
817: /*
818: --------------------------------------------------------------------------------
819: L'instruction est une donnée à empiler.
820: --------------------------------------------------------------------------------
821: */
822:
823: (*s_etat_processus).erreur_systeme = d_es;
824: (*s_etat_processus).type_en_cours = NON;
825: recherche_type(s_etat_processus);
826:
827: if ((*s_etat_processus).autorisation_nom_implicite == 'N')
828: {
829: if ((*s_etat_processus).l_base_pile == NULL)
830: {
831: if (((*s_etat_processus).erreur_execution !=
832: d_ex_nom_implicite) &&
833: ((*s_etat_processus).erreur_execution !=
834: d_ex_syntaxe))
835: {
836: (*s_etat_processus).erreur_execution =
837: d_ex_manque_argument;
838: }
839: }
840: else if ((*(*(*s_etat_processus).l_base_pile).donnee)
841: .type == NOM)
842: {
843: if ((*((struct_nom *) (*(*(*s_etat_processus)
844: .l_base_pile).donnee).objet)).symbole
845: == d_faux)
846: {
847: (*s_etat_processus).erreur_execution =
848: d_ex_nom_implicite;
849:
850: // Si le niveau de récursivité est non nul, on
851: // arrive ici depuis la fonction
852: // recherche_type(). On retourne à cette
853: // dernière en indiquant une erreur.
854:
855: if ((*s_etat_processus).niveau_recursivite != 0)
856: {
857: free((*s_etat_processus)
858: .instruction_courante);
859: return(d_erreur);
860: }
861: }
862: }
863: }
864:
865: // Le séquenceur est appelé depuis la routine d'évaluation
866:
867: if ((*s_etat_processus).evaluation_forcee == 'Y')
868: {
869: if (depilement(s_etat_processus,
870: &((*s_etat_processus).l_base_pile),
871: &s_objet_evaluation) == d_erreur)
872: {
873: free((*s_etat_processus).instruction_courante);
874: (*s_etat_processus).erreur_execution =
875: d_ex_manque_argument;
876: return(d_erreur);
877: }
878:
879: if (evaluation(s_etat_processus, s_objet_evaluation,
880: 'N') == d_erreur)
881: {
882: free((*s_etat_processus).instruction_courante);
883: liberation(s_etat_processus, s_objet_evaluation);
884: return(d_erreur);
885: }
886:
887: liberation(s_etat_processus, s_objet_evaluation);
888: }
889:
890: // Le séquenceur est appelé depuis la routine de
891: // recherche de type
892:
893: else if ((*s_etat_processus).recherche_type == 'Y')
894: {
895: if ((*s_etat_processus).erreur_execution != d_ex)
896: {
897: free((*s_etat_processus).instruction_courante);
898: return(d_erreur);
899: }
900: }
901: }
902: }
903: else if (((*s_etat_processus).test_instruction == 'Y') &&
904: ((*s_etat_processus).instruction_valide == 'Y'))
905: {
906:
907: /*
908: --------------------------------------------------------------------------------
909: Permet de traiter les fonctions dans les objets de type liste
910: --------------------------------------------------------------------------------
911: */
912:
913: if ((instruction_majuscule = conversion_majuscule(
914: s_etat_processus, (*s_etat_processus)
915: .instruction_courante)) == NULL)
916: {
917: (*s_etat_processus).erreur_systeme =
918: d_es_allocation_memoire;
919: return(d_erreur);
920: }
921:
922: if ((strcmp((*s_etat_processus).instruction_courante, "<<")
923: != 0) && (strcmp((*s_etat_processus)
924: .instruction_courante, ">>") != 0))
925: {
926: if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
927: {
928: (*s_etat_processus).erreur_systeme =
929: d_es_allocation_memoire;
930: return(d_erreur);
931: }
932:
933: (*((struct_fonction *) (*s_objet).objet))
934: .nombre_arguments = 0;
935:
936: if ((*s_etat_processus).instruction_intrinseque == 'Y')
937: {
938: if (((*((struct_fonction *) (*s_objet).objet))
939: .nom_fonction = conversion_majuscule(
940: s_etat_processus, (*s_etat_processus)
941: .instruction_courante)) == NULL)
942: {
943: (*s_etat_processus).erreur_systeme =
944: d_es_allocation_memoire;
945: return(d_erreur);
946: }
947: }
948: else
949: {
950: if (((*((struct_fonction *) (*s_objet).objet))
951: .nom_fonction = (unsigned char *) malloc(
952: (strlen((*s_etat_processus)
953: .instruction_courante)
954: + 1) * sizeof(unsigned char))) == NULL)
955: {
956: (*s_etat_processus).erreur_systeme =
957: d_es_allocation_memoire;
958: return(d_erreur);
959: }
960:
961: strcpy((*((struct_fonction *) (*s_objet).objet))
962: .nom_fonction, (*s_etat_processus)
963: .instruction_courante);
964: }
965:
966: (*((struct_fonction *) (*s_objet).objet)).fonction =
967: analyse_instruction(s_etat_processus,
968: (*s_etat_processus).instruction_courante);
969:
970: if (empilement(s_etat_processus,
971: &((*s_etat_processus).l_base_pile), s_objet) ==
972: d_erreur)
973: {
974: (*s_etat_processus).erreur_systeme =
975: d_es_allocation_memoire;
976: return(d_erreur);
977: }
978: }
979: else
980: {
981: (*s_etat_processus).test_instruction = 'N';
982: analyse(s_etat_processus, NULL);
983: (*s_etat_processus).test_instruction = 'Y';
984: }
985:
986: free(instruction_majuscule);
987: }
988:
989: erreur = (logical1) (erreur | (((*s_etat_processus)
990: .erreur_execution != d_ex) ? d_erreur : d_absence_erreur));
991: }
992: else
993: {
994: printf("\n");
995:
996: if ((*s_etat_processus).langue == 'F')
997: {
998: printf("+++Erreur : Argument %s invalide\n",
999: (*s_etat_processus).instruction_courante);
1000: }
1001: else
1002: {
1003: printf("+++Error : Invalid %s argument\n",
1004: (*s_etat_processus).instruction_courante);
1005: }
1006:
1007: fflush(stdout);
1008:
1009: free((*s_etat_processus).instruction_courante);
1010: return(d_erreur);
1011: }
1012:
1013: /*
1014: --------------------------------------------------------------------------------
1015: Traitement des arrêts simples
1016: --------------------------------------------------------------------------------
1017: */
1018:
1019: if ((*s_etat_processus).var_volatile_requete_arret2 != 0)
1020: {
1021: if ((*s_etat_processus).debug_programme == d_vrai)
1022: {
1023: (*s_etat_processus).var_volatile_requete_arret2 = 0;
1024: }
1025: else
1026: {
1027: if ((*s_etat_processus).var_volatile_requete_arret2 == -1)
1028: {
1029: if (strncmp(getenv("LANG"), "fr", 2) == 0)
1030: {
1031: printf("[%d] Arrêt\n", (int) getpid());
1032: }
1033: else
1034: {
1035: printf("[%d] Break\n", (int) getpid());
1036: }
1037:
1038: (*s_etat_processus).var_volatile_requete_arret2 = 1;
1039:
1040: fflush(stdout);
1041: }
1042:
1043: if ((*s_etat_processus).niveau_recursivite == 0)
1044: {
1045: (*s_etat_processus).debug_programme = d_vrai;
1046: (*s_etat_processus).var_volatile_requete_arret2 = 0;
1047: }
1048: }
1049: }
1050:
1051: /*
1052: * On ne sort pas du debugger en cas d'une erreur sur un programme
1053: * en cours de débogage.
1054: */
1055:
1056: if ((((*s_etat_processus).erreur_execution != d_ex) ||
1057: ((*s_etat_processus).exception != d_ep)) &&
1058: ((*s_etat_processus).debug_programme == d_vrai))
1059: {
1060: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1061: {
1062: l_element_courant = (*s_etat_processus).l_base_pile_last;
1063:
1064: while(l_element_courant != NULL)
1065: {
1066: if ((s_objet = copie_objet(s_etat_processus,
1067: (*l_element_courant).donnee, 'P')) == NULL)
1068: {
1069: (*s_etat_processus).erreur_systeme =
1070: d_es_allocation_memoire;
1071: return(d_erreur);
1072: }
1073:
1074: if (empilement(s_etat_processus, &((*s_etat_processus)
1075: .l_base_pile), s_objet) == d_erreur)
1076: {
1077: return(d_erreur);
1078: }
1079:
1080: l_element_courant = (*l_element_courant).suivant;
1081: }
1082: }
1083:
1084: if (test_cfsf(s_etat_processus, 51) == d_faux)
1085: {
1086: printf("%s", ds_beep);
1087: }
1088:
1089: if ((message = messages(s_etat_processus)) == NULL)
1090: {
1091: free((*s_etat_processus).instruction_courante);
1092: return(d_erreur);
1093: }
1094:
1095: printf("%s [%d]\n", message, (int) getpid());
1096:
1097: free(message);
1098:
1099: (*s_etat_processus).erreur_execution = d_ex;
1100: (*s_etat_processus).exception = d_ep;
1101: erreur = d_absence_erreur;
1102:
1103: (*s_etat_processus).position_courante -= (integer8)
1104: strlen((*s_etat_processus).instruction_courante);
1105: }
1106:
1107: /*
1108: --------------------------------------------------------------------------------
1109: Test de fin d'exécution du programme RPL/2
1110: --------------------------------------------------------------------------------
1111: */
1112:
1113: if (((*s_etat_processus).niveau_courant == 0) &&
1114: (drapeau_appel_definition != d_vrai))
1115: {
1116: drapeau_fin = d_vrai;
1117: }
1118: else if ((*s_etat_processus).requete_arret == 'Y')
1119: {
1120: drapeau_fin = d_vrai;
1121: }
1122: else if (((*s_etat_processus).var_volatile_requete_arret != 0)
1123: && ((*s_etat_processus).debug_programme == d_faux))
1124: {
1125: drapeau_fin = d_vrai;
1126:
1127: if ((*s_etat_processus).erreur_systeme == d_es)
1128: {
1129: erreur = d_absence_erreur;
1130: }
1131: }
1132: else if ((*s_etat_processus).arret_si_exception == d_vrai)
1133: {
1134: drapeau_fin = d_faux;
1135:
1136: if ((*s_etat_processus).exception != d_ep)
1137: {
1138: erreur = d_erreur;
1139: }
1140: else if ((*s_etat_processus).erreur_systeme != d_es)
1141: {
1142: erreur = d_erreur;
1143: }
1144: }
1145: else if ((*s_etat_processus).arret_si_exception == d_faux)
1146: {
1147: if ((message = messages(s_etat_processus)) == NULL)
1148: {
1149: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1150: return(d_erreur);
1151: }
1152:
1153: free(message);
1154:
1155: drapeau_fin = d_faux;
1156:
1157: /*
1158: --------------------------------------------------------------------------------
1159: Traitement des exceptions
1160: --------------------------------------------------------------------------------
1161: */
1162:
1163: if ((*s_etat_processus).erreur_systeme != d_es)
1164: {
1165: erreur = d_erreur;
1166: }
1167: else if (((*s_etat_processus).exception != d_ep) ||
1168: ((*s_etat_processus).erreur_execution != d_ex))
1169: {
1170: tampon = (*s_etat_processus).instruction_courante;
1171:
1172: while((*(*s_etat_processus).l_base_pile_systeme).clause != 'R')
1173: {
1174: erreur = recherche_instruction_suivante(s_etat_processus);
1175:
1176: if (erreur == d_erreur)
1177: {
1178: free((*s_etat_processus).instruction_courante);
1179: return(d_erreur);
1180: }
1181:
1182: if (recherche_variable(s_etat_processus,
1183: (*s_etat_processus).instruction_courante) == d_vrai)
1184: {
1185: if ((*(*s_etat_processus).pointeur_variable_courante)
1186: .objet == NULL)
1187: {
1188: // Variable partagée
1189: }
1190: else if ((*(*(*s_etat_processus)
1191: .pointeur_variable_courante).objet).type == ADR)
1192: {
1193: empilement_pile_systeme(s_etat_processus);
1194:
1195: if ((*s_etat_processus).erreur_systeme != d_es)
1196: {
1197: free((*s_etat_processus).instruction_courante);
1198: return(d_erreur);
1199: }
1200:
1201: (*(*s_etat_processus).l_base_pile_systeme)
1202: .adresse_retour = (*s_etat_processus)
1203: .position_courante;
1204:
1205: (*(*s_etat_processus).l_base_pile_systeme)
1206: .retour_definition = 'Y';
1207:
1208: (*(*s_etat_processus).l_base_pile_systeme)
1209: .niveau_courant = (*s_etat_processus)
1210: .niveau_courant;
1211:
1212: (*s_etat_processus).position_courante =
1213: (*((integer8 *)
1214: ((*(*(*s_etat_processus)
1215: .pointeur_variable_courante)
1216: .objet).objet)));
1217:
1218: (*s_etat_processus)
1219: .autorisation_empilement_programme = 'N';
1220: }
1221: }
1222: else
1223: {
1224: (*s_etat_processus).erreur_systeme = d_es;
1225: instruction_majuscule = conversion_majuscule(
1226: s_etat_processus, (*s_etat_processus)
1227: .instruction_courante);
1228:
1229: if (instruction_majuscule == NULL)
1230: {
1231: free((*s_etat_processus).instruction_courante);
1232: return(d_erreur);
1233: }
1234:
1235: /*
1236: * Traitement de la pile système par les
1237: * différentes instructions.
1238: */
1239:
1240: if ((strcmp(instruction_majuscule, "IF") == 0) ||
1241: (strcmp(instruction_majuscule, "IFERR") == 0) ||
1242: (strcmp(instruction_majuscule, "DO") == 0) ||
1243: (strcmp(instruction_majuscule, "WHILE") == 0) ||
1244: (strcmp(instruction_majuscule, "FOR") == 0) ||
1245: (strcmp(instruction_majuscule, "FORALL") == 0)
1246: ||
1247: (strcmp(instruction_majuscule, "START") == 0) ||
1248: (strcmp(instruction_majuscule, "SELECT") == 0)
1249: ||
1250: (strcmp(instruction_majuscule, "CRITICAL") == 0)
1251: || (strcmp(instruction_majuscule, "CASE") == 0)
1252: || (strcmp(instruction_majuscule, "<<") == 0))
1253: {
1254: if (strcmp(instruction_majuscule, "<<") == 0)
1255: {
1256: analyse(s_etat_processus, NULL);
1257: }
1258: else if ((strcmp(instruction_majuscule, "FOR") == 0)
1259: || (strcmp(instruction_majuscule, "FORALL")
1260: == 0) || (strcmp(instruction_majuscule,
1261: "START") == 0))
1262: {
1263: empilement_pile_systeme(s_etat_processus);
1264:
1265: if ((*s_etat_processus).erreur_systeme != d_es)
1266: {
1267: return(d_erreur);
1268: }
1269:
1270: (*(*s_etat_processus).l_base_pile_systeme)
1271: .type_cloture = 'L';
1272: }
1273: else
1274: {
1275: empilement_pile_systeme(s_etat_processus);
1276:
1277: if ((*s_etat_processus).erreur_systeme != d_es)
1278: {
1279: return(d_erreur);
1280: }
1281: }
1282: }
1283: else if ((strcmp(instruction_majuscule, "END") == 0) ||
1284: (strcmp(instruction_majuscule, "NEXT") == 0) ||
1285: (strcmp(instruction_majuscule, "STEP") == 0) ||
1286: (strcmp(instruction_majuscule, ">>") == 0))
1287: {
1288: if (strcmp(instruction_majuscule, ">>") == 0)
1289: {
1290: analyse(s_etat_processus, NULL);
1291:
1292: if ((*(*s_etat_processus).l_base_pile_systeme)
1293: .origine_routine_evaluation == 'Y')
1294: {
1295: free(instruction_majuscule);
1296: free((*s_etat_processus)
1297: .instruction_courante);
1298:
1299: (*s_etat_processus).instruction_courante =
1300: tampon;
1301:
1302: return(d_absence_erreur);
1303: }
1304: }
1305: else if (((strcmp(instruction_majuscule, "NEXT")
1306: == 0) || (strcmp(instruction_majuscule,
1307: "STEP") == 0)) && ((*(*s_etat_processus)
1308: .l_base_pile_systeme).type_cloture != 'L'))
1309: {
1310: /*
1311: * Libération des compteurs de boucle.
1312: */
1313:
1314: presence_compteur = (((*(*s_etat_processus)
1315: .l_base_pile_systeme).type_cloture
1316: == 'F') || ((*(*s_etat_processus)
1317: .l_base_pile_systeme).type_cloture
1318: == 'A')) ? d_vrai : d_faux;
1319:
1320: if (((*(*s_etat_processus).l_base_pile_systeme)
1321: .type_cloture != 'S') &&
1322: (presence_compteur == d_faux))
1323: {
1324: return(d_erreur);
1325: }
1326:
1327: if (presence_compteur == d_vrai)
1328: {
1329: if (recherche_variable(s_etat_processus,
1330: (*(*s_etat_processus)
1331: .l_base_pile_systeme).nom_variable)
1332: == d_faux)
1333: {
1334: return(d_erreur);
1335: }
1336:
1337: if ((*(*s_etat_processus)
1338: .pointeur_variable_courante).objet
1339: == NULL)
1340: {
1341: return(d_erreur);
1342: }
1343:
1344: (*s_etat_processus).niveau_courant--;
1345:
1346: if (retrait_variables_par_niveau(
1347: s_etat_processus) == d_erreur)
1348: {
1349: return(d_erreur);
1350: }
1351: }
1352:
1353: depilement_pile_systeme(s_etat_processus);
1354:
1355: if ((*s_etat_processus).erreur_systeme != d_es)
1356: {
1357: return(d_erreur);
1358: }
1359: }
1360: else
1361: {
1362: // Traitement spécifique pour la fin
1363: // d'une section critique
1364:
1365: if ((*s_etat_processus).l_base_pile_systeme
1366: == NULL)
1367: {
1368: (*s_etat_processus).erreur_systeme =
1369: d_es_processus;
1370: return(d_erreur);
1371: }
1372:
1373: if ((*(*s_etat_processus).l_base_pile_systeme)
1374: .type_cloture == 'Q')
1375: {
1376: if (pthread_mutex_unlock(
1377: &mutex_sections_critiques) != 0)
1378: {
1379: (*s_etat_processus).erreur_systeme =
1380: d_es_processus;
1381: return(d_erreur);
1382: }
1383:
1384: (*s_etat_processus).sections_critiques--;
1385: }
1386:
1387: depilement_pile_systeme(s_etat_processus);
1388:
1389: if ((*s_etat_processus).erreur_systeme != d_es)
1390: {
1391: return(d_erreur);
1392: }
1393: }
1394: }
1395:
1396: free(instruction_majuscule);
1397: }
1398:
1399: free((*s_etat_processus).instruction_courante);
1400: }
1401:
1402: drapeau_then = d_faux;
1403: niveau = 0;
1404:
1405: do
1406: {
1407: erreur = recherche_instruction_suivante(s_etat_processus);
1408:
1409: if (erreur == d_erreur)
1410: {
1411: return(d_erreur);
1412: }
1413:
1414: instruction_majuscule = conversion_majuscule(
1415: s_etat_processus,
1416: (*s_etat_processus).instruction_courante);
1417:
1418: if (instruction_majuscule == NULL)
1419: {
1420: return(d_erreur);
1421: }
1422:
1423: if ((strcmp(instruction_majuscule, "IF") == 0) ||
1424: (strcmp(instruction_majuscule, "IFERR") == 0) ||
1425: (strcmp(instruction_majuscule, "DO") == 0) ||
1426: (strcmp(instruction_majuscule, "WHILE") == 0) ||
1427: (strcmp(instruction_majuscule, "FOR") == 0) ||
1428: (strcmp(instruction_majuscule, "FORALL") == 0) ||
1429: (strcmp(instruction_majuscule, "START") == 0) ||
1430: (strcmp(instruction_majuscule, "SELECT") == 0)
1431: || (strcmp(instruction_majuscule, "CRITICAL") == 0)
1432: || (strcmp(instruction_majuscule, "CASE") == 0)
1433: || (strcmp(instruction_majuscule, "<<") == 0))
1434: {
1435: niveau++;
1436: }
1437: else if ((strcmp(instruction_majuscule, "END") == 0) ||
1438: (strcmp(instruction_majuscule, "NEXT") == 0) ||
1439: (strcmp(instruction_majuscule, "STEP") == 0) ||
1440: (strcmp(instruction_majuscule, ">>") == 0))
1441: {
1442: niveau--;
1443: }
1444:
1445: drapeau_then = ((strcmp(instruction_majuscule, "THEN") == 0)
1446: && (niveau == 0)) ? d_vrai : d_faux;
1447:
1448: free(instruction_majuscule);
1449: free((*s_etat_processus).instruction_courante);
1450: } while(drapeau_then == d_faux);
1451:
1452: (*s_etat_processus).position_courante -= 5;
1453: (*s_etat_processus).instruction_courante = tampon;
1454: (*(*s_etat_processus).l_base_pile_systeme).clause = 'X';
1455:
1456: erreur = d_absence_erreur;
1457: (*s_etat_processus).exception = d_ep;
1458: (*s_etat_processus).erreur_execution = d_ex;
1459: }
1460: }
1461: else
1462: {
1463: drapeau_fin = d_faux;
1464: }
1465:
1466: if (erreur == d_absence_erreur)
1467: {
1468: free((*s_etat_processus).instruction_courante);
1469: }
1470: } while((erreur == d_absence_erreur) &&
1471: ((*s_etat_processus).position_courante <
1472: (*s_etat_processus).longueur_definitions_chainees) &&
1473: (drapeau_fin == d_faux) &&
1474: ((*s_etat_processus).retour_routine_evaluation == 'N'));
1475:
1476: /*
1477: --------------------------------------------------------------------------------
1478: Messages d'erreur à afficher le cas échéant
1479: --------------------------------------------------------------------------------
1480: */
1481:
1482: if ((erreur != d_absence_erreur) && ((*s_etat_processus)
1483: .invalidation_message_erreur == d_faux))
1484: {
1485: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1486: {
1487: l_element_courant = (*s_etat_processus).l_base_pile_last;
1488:
1489: while(l_element_courant != NULL)
1490: {
1491: if ((s_objet = copie_objet(s_etat_processus,
1492: (*l_element_courant).donnee, 'P')) == NULL)
1493: {
1494: (*s_etat_processus).erreur_systeme =
1495: d_es_allocation_memoire;
1496: return(d_erreur);
1497: }
1498:
1499: if (empilement(s_etat_processus, &((*s_etat_processus)
1500: .l_base_pile), s_objet) == d_erreur)
1501: {
1502: return(d_erreur);
1503: }
1504:
1505: l_element_courant = (*l_element_courant).suivant;
1506: }
1507: }
1508:
1509: if (test_cfsf(s_etat_processus, 51) == d_faux)
1510: {
1511: printf("%s", ds_beep);
1512: }
1513:
1514: if ((message = messages(s_etat_processus)) == NULL)
1515: {
1516: return(d_erreur);
1517: }
1518:
1519: printf("%s [%d]\n", message, (int) getpid());
1520:
1521: free(message);
1522: free((*s_etat_processus).instruction_courante);
1523:
1524: if ((*s_etat_processus).var_volatile_processus_pere == 0)
1525: {
1526: envoi_signal_processus((*s_etat_processus).pid_processus_pere,
1527: rpl_sigalrm);
1528: }
1529: else
1530: {
1531: (*s_etat_processus).var_volatile_alarme = -1;
1532: }
1533:
1534: return(d_erreur);
1535: }
1536:
1537: return(d_absence_erreur);
1538: }
1539:
1540: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>