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