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