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