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