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