![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to evaluation.c CVS log | Up to [local] / rpl / src |
Correction d'un problème d'évaluation des éléments des listes et des tables dans evaluation().
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.23
4: Copyright (C) 1989-2015 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: #define TEST(instruction) (fonction == instruction)
26: #define vers_niveau_inferieur instruction_vers_niveau_inferieur
27: #define vers_niveau_superieur instruction_vers_niveau_superieur
28:
29:
30: /*
31: ================================================================================
32: Evaluation d'une expression
33: ================================================================================
34: Entrées :
35: structure processus,
36: objet à évaluer (non libéré au retour de la routine)
37: et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')
38: --------------------------------------------------------------------------------
39: Sorties : objet évalué au niveau 1 de la pile
40: --------------------------------------------------------------------------------
41: Effets de bord : néant
42: ================================================================================
43: */
44:
45: logical1
46: evaluation(struct_processus *s_etat_processus, struct_objet *s_objet,
47: unsigned char type_evaluation)
48: {
49: integer8 i;
50: integer8 j;
51: integer8 k;
52: integer8 l;
53: integer8 niveau_initial;
54: integer8 nombre_termes;
55: integer8 registre_hauteur_pile_operationnelle;
56: integer8 registre_position_courante;
57:
58:
59: logical1 drapeau_then;
60: logical1 erreur_evaluation;
61: logical1 presence_compteur;
62: logical1 presence_egalite;
63: logical1 presence_fonction;
64: logical1 presence_variable;
65: logical1 presence_variable_partagee;
66:
67: struct_liste_chainee *l_element_courant;
68: struct_liste_chainee *l_element_egalite;
69: struct_liste_chainee *l_element_fonction;
70: struct_liste_chainee *l_liste1;
71: struct_liste_chainee *l_liste2;
72: struct_liste_chainee *l_registre_atome;
73: struct_liste_chainee *l_registre_pile_operationnelle;
74: struct_liste_chainee *l_sous_element_courant;
75: struct_liste_chainee *registre_expression_courante;
76:
77: struct_liste_pile_systeme *pile_systeme_originelle;
78:
79: struct_objet *s_objet_elementaire;
80: struct_objet *s_objet_evalue;
81: struct_objet *s_objet_indice_i;
82: struct_objet *s_objet_indice_j;
83: struct_objet *s_objet_tampon;
84: struct_objet *s_sous_objet;
85: struct_objet *s_copie_variable_partagee;
86:
87: unsigned char autorisation_empilement_programme;
88: unsigned char *instruction_courante;
89: unsigned char *message;
90: unsigned char registre_evaluation_expression_compilee;
91: unsigned char registre_evaluation_forcee;
92: unsigned char registre_instruction_valide;
93: unsigned char registre_mode_execution_programme;
94: unsigned char registre_test;
95: unsigned char registre_test_2;
96: unsigned char registre_type_evaluation;
97:
98: int registre_erreur_execution;
99: int registre_erreur_systeme;
100: int registre_exception;
101:
102: void (*fonction)();
103:
104: registre_mode_execution_programme =
105: (*s_etat_processus).mode_execution_programme;
106: (*s_etat_processus).mode_execution_programme = 'I';
107: instruction_courante = (*s_etat_processus).instruction_courante;
108: (*s_etat_processus).erreur_execution = d_ex;
109:
110: erreur_evaluation = d_absence_erreur;
111: s_copie_variable_partagee = NULL;
112:
113: if ((*s_objet).type == NOM)
114: {
115: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
116: == NULL)
117: {
118: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
119: (*s_etat_processus).instruction_courante = instruction_courante;
120: return(d_erreur);
121: }
122:
123: registre_instruction_valide = (*s_etat_processus).instruction_valide;
124: registre_test = (*s_etat_processus).test_instruction;
125: (*s_etat_processus).test_instruction = 'Y';
126: (*s_etat_processus).instruction_courante = (*((struct_nom *)
127: (*s_objet_tampon).objet)).nom;
128:
129: analyse(s_etat_processus, NULL);
130:
131: (*s_etat_processus).test_instruction = 'N';
132:
133: if ((*s_etat_processus).constante_symbolique == 'N')
134: {
135: presence_fonction = d_faux;
136: presence_variable_partagee = d_faux;
137:
138: if (recherche_variable(s_etat_processus, (*((struct_nom *)
139: (*s_objet_tampon).objet)).nom) == d_faux)
140: {
141: (*s_etat_processus).erreur_execution = d_ex;
142:
143: if ((*s_etat_processus).autorisation_nom_implicite == 'N')
144: {
145: if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
146: d_faux)
147: {
148: if (test_cfsf(s_etat_processus, 31) == d_vrai)
149: {
150: if (empilement_pile_last(s_etat_processus, 0)
151: == d_erreur)
152: {
153: return(d_erreur);
154: }
155: }
156:
157: erreur_evaluation = d_erreur;
158: (*s_etat_processus).erreur_execution =
159: d_ex_nom_implicite;
160:
161: if (type_evaluation == 'I')
162: {
163: (*s_etat_processus).derniere_erreur_evaluation =
164: (*s_etat_processus).erreur_execution;
165: }
166: }
167: }
168:
169: (*s_etat_processus).erreur_systeme = d_es;
170: presence_variable = d_faux;
171: }
172: else
173: {
174: if ((*s_etat_processus).traitement_symbolique == 'N')
175: {
176: if ((*(*s_etat_processus).pointeur_variable_courante)
177: .objet == NULL)
178: {
179: // Variable partagée
180:
181: presence_variable_partagee = d_faux;
182:
183: if (recherche_variable_partagee(s_etat_processus,
184: (*(*s_etat_processus)
185: .pointeur_variable_courante).nom,
186: (*(*s_etat_processus)
187: .pointeur_variable_courante)
188: .variable_partagee, 'E') != NULL)
189: {
190: presence_variable = d_vrai;
191: presence_variable_partagee = d_vrai;
192:
193: if ((*(*(*s_etat_processus)
194: .pointeur_variable_partagee_courante).objet)
195: .type == ADR)
196: {
197: presence_fonction = d_vrai;
198: }
199:
200: if ((s_copie_variable_partagee =
201: copie_objet(s_etat_processus,
202: (*(*s_etat_processus)
203: .pointeur_variable_partagee_courante).objet,
204: 'P')) == NULL)
205: {
206: (*s_etat_processus).erreur_systeme =
207: d_es_allocation_memoire;
208:
209: if (pthread_mutex_unlock(&((*(*s_etat_processus)
210: .pointeur_variable_partagee_courante)
211: .mutex)) != 0)
212: {
213: (*s_etat_processus).erreur_systeme =
214: d_es_processus;
215: return(d_erreur);
216: }
217:
218: return(d_erreur);
219: }
220:
221: if (pthread_mutex_unlock(&((*(*s_etat_processus)
222: .pointeur_variable_partagee_courante)
223: .mutex)) != 0)
224: {
225: (*s_etat_processus).erreur_systeme =
226: d_es_processus;
227: return(d_erreur);
228: }
229: }
230: else
231: {
232: (*s_etat_processus).erreur_systeme = d_es;
233: presence_variable = d_faux;
234: presence_variable_partagee = d_faux;
235: }
236: }
237: else
238: {
239: // Variable privée
240:
241: presence_variable = d_vrai;
242:
243: if ((*(*(*s_etat_processus).pointeur_variable_courante)
244: .objet).type == ADR)
245: {
246: presence_fonction = d_vrai;
247: }
248: }
249: }
250: else
251: {
252: presence_variable = d_faux;
253: }
254: }
255:
256: liberation(s_etat_processus, s_objet_tampon);
257:
258: if (presence_fonction == d_vrai)
259: {
260: autorisation_empilement_programme = (*s_etat_processus)
261: .autorisation_empilement_programme;
262: registre_position_courante = (*s_etat_processus)
263: .position_courante;
264:
265: empilement_pile_systeme(s_etat_processus);
266:
267: if ((*s_etat_processus).erreur_systeme != d_es)
268: {
269: if (presence_variable_partagee == d_vrai)
270: {
271: liberation(s_etat_processus, s_copie_variable_partagee);
272: }
273:
274: (*s_etat_processus).instruction_courante =
275: instruction_courante;
276: return(d_erreur);
277: }
278:
279: (*(*s_etat_processus).l_base_pile_systeme)
280: .retour_definition = 'Y';
281: (*(*s_etat_processus).l_base_pile_systeme)
282: .origine_routine_evaluation = 'Y';
283:
284: (*s_etat_processus).mode_execution_programme = 'Y';
285: (*s_etat_processus).autorisation_empilement_programme = 'N';
286:
287: (*(*s_etat_processus).l_base_pile_systeme)
288: .niveau_courant = (*s_etat_processus).niveau_courant;
289:
290: if (presence_variable_partagee == d_faux)
291: {
292: (*s_etat_processus).position_courante =
293: (*((integer8 *) ((*(*(*s_etat_processus)
294: .pointeur_variable_courante).objet).objet)));
295: }
296: else
297: {
298: (*s_etat_processus).position_courante =
299: (*((integer8 *) (*s_copie_variable_partagee)
300: .objet));
301: liberation(s_etat_processus, s_copie_variable_partagee);
302: }
303:
304: if ((*s_etat_processus).profilage == d_vrai)
305: {
306: profilage(s_etat_processus,
307: (*(*s_etat_processus).pointeur_variable_courante)
308: .nom);
309:
310: if ((*s_etat_processus).erreur_systeme != d_es)
311: {
312: return(d_erreur);
313: }
314: }
315:
316: registre_evaluation_forcee =
317: (*s_etat_processus).evaluation_forcee;
318:
319: if (type_evaluation == 'N')
320: {
321: (*s_etat_processus).evaluation_forcee = 'Y';
322: }
323:
324: if (sequenceur(s_etat_processus) == d_erreur)
325: {
326: depilement_pile_systeme(s_etat_processus);
327:
328: (*s_etat_processus).evaluation_forcee =
329: registre_evaluation_forcee;
330: (*s_etat_processus).mode_execution_programme =
331: registre_mode_execution_programme;
332: (*s_etat_processus).instruction_courante =
333: instruction_courante;
334: return(d_erreur);
335: }
336:
337: (*s_etat_processus).evaluation_forcee =
338: registre_evaluation_forcee;
339: (*s_etat_processus).instruction_courante =
340: instruction_courante;
341: (*s_etat_processus).mode_execution_programme = 'N';
342:
343: depilement_pile_systeme(s_etat_processus);
344:
345: if ((*s_etat_processus).erreur_systeme != d_es)
346: {
347: return(d_erreur);
348: }
349:
350: (*s_etat_processus).retour_routine_evaluation = 'N';
351: (*s_etat_processus).position_courante =
352: registre_position_courante;
353: (*s_etat_processus).autorisation_empilement_programme =
354: autorisation_empilement_programme;
355: }
356: else if (presence_variable == d_vrai)
357: {
358: registre_evaluation_expression_compilee =
359: (*s_etat_processus).evaluation_expression_compilee;
360:
361: if (((*(*s_etat_processus).pointeur_variable_courante).origine
362: == 'E') && ((*(*s_etat_processus)
363: .pointeur_variable_courante).niveau == 0))
364: {
365: (*s_etat_processus).evaluation_expression_compilee = 'Y';
366: }
367: else
368: {
369: (*s_etat_processus).evaluation_expression_compilee = 'N';
370: }
371:
372: if ((*s_etat_processus).profilage == d_vrai)
373: {
374: profilage(s_etat_processus,
375: (*(*s_etat_processus).pointeur_variable_courante)
376: .nom);
377:
378: if ((*s_etat_processus).erreur_systeme != d_es)
379: {
380: return(d_erreur);
381: }
382: }
383:
384: autorisation_empilement_programme = (*s_etat_processus)
385: .autorisation_empilement_programme;
386:
387: empilement_pile_systeme(s_etat_processus);
388:
389: if ((*s_etat_processus).erreur_systeme != d_es)
390: {
391: if (presence_variable_partagee == d_vrai)
392: {
393: liberation(s_etat_processus, s_copie_variable_partagee);
394: }
395:
396: (*s_etat_processus).instruction_courante =
397: instruction_courante;
398: return(d_erreur);
399: }
400:
401: (*(*s_etat_processus).l_base_pile_systeme)
402: .retour_definition = 'Y';
403: (*(*s_etat_processus).l_base_pile_systeme)
404: .origine_routine_evaluation = 'Y';
405:
406: (*s_etat_processus).mode_execution_programme = 'Y';
407: (*s_etat_processus).autorisation_empilement_programme = 'N';
408:
409: (*(*s_etat_processus).l_base_pile_systeme)
410: .niveau_courant = (*s_etat_processus)
411: .niveau_courant;
412:
413: if (presence_variable_partagee == d_faux)
414: {
415: if (evaluation(s_etat_processus, (*(*s_etat_processus)
416: .pointeur_variable_courante).objet,
417: type_evaluation) == d_erreur)
418: {
419: if ((*s_etat_processus).profilage == d_vrai)
420: {
421: profilage(s_etat_processus, NULL);
422: }
423:
424: depilement_pile_systeme(s_etat_processus);
425:
426: (*s_etat_processus).evaluation_expression_compilee =
427: registre_evaluation_expression_compilee;
428:
429: (*s_etat_processus).mode_execution_programme =
430: registre_mode_execution_programme;
431: (*s_etat_processus).instruction_courante =
432: instruction_courante;
433: return(d_erreur);
434: }
435: }
436: else
437: {
438: if (evaluation(s_etat_processus, s_copie_variable_partagee,
439: type_evaluation) == d_erreur)
440: {
441: liberation(s_etat_processus, s_copie_variable_partagee);
442:
443: if ((*s_etat_processus).profilage == d_vrai)
444: {
445: profilage(s_etat_processus, NULL);
446: }
447:
448: depilement_pile_systeme(s_etat_processus);
449:
450: (*s_etat_processus).evaluation_expression_compilee =
451: registre_evaluation_expression_compilee;
452:
453: (*s_etat_processus).mode_execution_programme =
454: registre_mode_execution_programme;
455: (*s_etat_processus).instruction_courante =
456: instruction_courante;
457: return(d_erreur);
458: }
459:
460: liberation(s_etat_processus, s_copie_variable_partagee);
461: }
462:
463: if ((*s_etat_processus).profilage == d_vrai)
464: {
465: profilage(s_etat_processus, NULL);
466: }
467:
468: depilement_pile_systeme(s_etat_processus);
469:
470: if ((*s_etat_processus).erreur_systeme != d_es)
471: {
472: return(d_erreur);
473: }
474:
475: (*s_etat_processus).evaluation_expression_compilee =
476: registre_evaluation_expression_compilee;
477: (*s_etat_processus).autorisation_empilement_programme =
478: autorisation_empilement_programme;
479: }
480: else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
481: {
482: if ((s_objet_tampon = copie_objet(s_etat_processus,
483: s_objet, 'Q')) == NULL)
484: {
485: (*s_etat_processus).erreur_systeme =
486: d_es_allocation_memoire;
487: (*s_etat_processus).instruction_courante =
488: instruction_courante;
489: return(d_erreur);
490: }
491:
492: (*((struct_nom *) (*s_objet_tampon).objet)).symbole = d_vrai;
493:
494: if (empilement(s_etat_processus, &((*s_etat_processus)
495: .l_base_pile), s_objet_tampon) == d_erreur)
496: {
497: (*s_etat_processus).instruction_courante =
498: instruction_courante;
499: return(d_erreur);
500: }
501: }
502: }
503: else
504: {
505: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
506: == d_vrai) ? 'E' : 'N';
507:
508: if (type_evaluation == 'N')
509: {
510: cf(s_etat_processus, 35);
511: }
512: else
513: {
514: sf(s_etat_processus, 35);
515: }
516:
517: analyse(s_etat_processus, NULL);
518: liberation(s_etat_processus, s_objet_tampon);
519:
520: if (registre_type_evaluation == 'E')
521: {
522: sf(s_etat_processus, 35);
523: }
524: else
525: {
526: cf(s_etat_processus, 35);
527: }
528:
529: if (((*s_etat_processus).erreur_systeme != d_es) ||
530: ((*s_etat_processus).erreur_execution != d_ex) ||
531: ((*s_etat_processus).exception != d_ep))
532: {
533: (*s_etat_processus).mode_execution_programme =
534: registre_mode_execution_programme;
535: (*s_etat_processus).instruction_courante = instruction_courante;
536: return(d_erreur);
537: }
538: }
539:
540: (*s_etat_processus).instruction_courante = instruction_courante;
541: (*s_etat_processus).test_instruction = registre_test;
542: (*s_etat_processus).instruction_valide = registre_instruction_valide;
543: }
544: else if (((*s_objet).type == RPN) || ((*s_objet).type == ALG))
545: {
546: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
547: l_element_egalite = NULL;
548: presence_egalite = d_faux;
549: nombre_termes = 0;
550:
551: while(l_element_courant != NULL)
552: {
553: if ((*(*l_element_courant).donnee).type == FCT)
554: {
555: if (strcmp((*((struct_fonction *) (*(*l_element_courant)
556: .donnee).objet)).nom_fonction, "=") == 0)
557: {
558: presence_egalite = d_vrai;
559: l_element_egalite = l_element_courant;
560: }
561: }
562:
563: l_element_courant = (*l_element_courant).suivant;
564: nombre_termes++;
565: }
566:
567: if (nombre_termes <= 4)
568: {
569: presence_egalite = d_faux;
570: }
571:
572: if (presence_egalite == d_vrai)
573: {
574: // S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
575: // le signe '=' et en le remplaçant d'une part par SWAP DROP
576: // et d'autre part par DROP. On évalue la première puis la
577: // seconde normalement avant de reconstituer le tout à la fin
578: // de la routine.
579:
580: l_registre_pile_operationnelle = NULL;
581: registre_hauteur_pile_operationnelle = (*s_etat_processus)
582: .hauteur_pile_operationnelle;
583: l_element_courant = (*s_etat_processus).l_base_pile;
584:
585: while(l_element_courant != NULL)
586: {
587: s_sous_objet = copie_objet(s_etat_processus,
588: (*l_element_courant).donnee, 'O');
589:
590: if (s_sous_objet == NULL)
591: {
592: (*s_etat_processus).instruction_courante =
593: instruction_courante;
594: (*s_etat_processus).erreur_systeme =
595: d_es_allocation_memoire;
596: return(d_erreur);
597: }
598:
599: if (empilement(s_etat_processus,
600: &l_registre_pile_operationnelle, s_sous_objet)
601: == d_erreur)
602: {
603: (*s_etat_processus).instruction_courante =
604: instruction_courante;
605: (*s_etat_processus).erreur_systeme =
606: d_es_allocation_memoire;
607: return(d_erreur);
608: }
609:
610: l_element_courant = (*l_element_courant).suivant;
611: }
612:
613: free((*((struct_fonction *) (*(*l_element_egalite).donnee)
614: .objet)).nom_fonction);
615:
616: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
617: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
618: {
619: (*s_etat_processus).instruction_courante = instruction_courante;
620: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
621: return(d_erreur);
622: }
623:
624: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
625: .fonction = instruction_drop;
626: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
627: .nom_fonction, "DROP");
628:
629: if (evaluation(s_etat_processus, s_objet, type_evaluation)
630: == d_erreur)
631: {
632: (*s_etat_processus).instruction_courante = instruction_courante;
633: return(d_erreur);
634: }
635:
636: // Récupération de l'objet au niveau 1 résultat de l'évaluation
637: // du premier membre de l'équation puis destruction de la pile.
638:
639: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
640: &s_objet_evalue) == d_erreur)
641: {
642: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
643: (*s_etat_processus).instruction_courante = instruction_courante;
644: return(d_erreur);
645: }
646:
647: instruction_clear(s_etat_processus);
648:
649: // Régénération de la pile initiale
650:
651: while(depilement(s_etat_processus, &l_registre_pile_operationnelle,
652: &s_sous_objet) != d_erreur)
653: {
654: if (empilement(s_etat_processus, &((*s_etat_processus)
655: .l_base_pile), s_sous_objet) == d_erreur)
656: {
657: (*s_etat_processus).instruction_courante =
658: instruction_courante;
659: return(d_erreur);
660: }
661: }
662:
663: (*s_etat_processus).hauteur_pile_operationnelle =
664: registre_hauteur_pile_operationnelle;
665: (*s_etat_processus).erreur_execution = d_ex;
666:
667: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
668: .fonction = instruction_swap;
669: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
670: .nom_fonction, "SWAP");
671: l_element_courant = (*l_element_egalite).suivant;
672:
673: if (((*l_element_egalite).suivant =
674: malloc(sizeof(struct_liste_chainee))) == NULL)
675: {
676: liberation(s_etat_processus, s_objet_evalue);
677:
678: (*s_etat_processus).instruction_courante = instruction_courante;
679: return(d_erreur);
680: }
681:
682: l_element_egalite = (*l_element_egalite).suivant;
683: (*l_element_egalite).suivant = l_element_courant;
684:
685: if (((*l_element_egalite).donnee = allocation(s_etat_processus,
686: FCT)) == NULL)
687: {
688: liberation(s_etat_processus, s_objet_evalue);
689:
690: (*s_etat_processus).instruction_courante = instruction_courante;
691: return(d_erreur);
692: }
693:
694: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
695: .nombre_arguments = 0;
696: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
697: .fonction = instruction_drop;
698:
699: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
700: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
701: {
702: liberation(s_etat_processus, s_objet_evalue);
703:
704: (*s_etat_processus).instruction_courante = instruction_courante;
705: return(d_erreur);
706: }
707:
708: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
709: .nom_fonction, "DROP");
710: }
711:
712: /*
713: * Exécution de la séquence d'instructions
714: */
715:
716: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
717: autorisation_empilement_programme = (*s_etat_processus)
718: .autorisation_empilement_programme;
719: (*s_etat_processus).autorisation_empilement_programme = 'N';
720:
721: niveau_initial = (*s_etat_processus).niveau_courant;
722: pile_systeme_originelle = (*s_etat_processus).l_base_pile_systeme;
723:
724: while((l_element_courant != NULL) &&
725: ((*s_etat_processus).var_volatile_requete_arret == 0)
726: && (erreur_evaluation == d_absence_erreur) &&
727: (*s_etat_processus).requete_arret == 'N')
728: {
729: (*s_etat_processus).objet_courant = (*l_element_courant).donnee;
730:
731: if ((*(*l_element_courant).donnee).type == FCT)
732: {
733: /*
734: * Tester la cohérence avec une variable pour récupérer les
735: * données selon les indices passés en argument (tableaux,
736: * listes...).
737: */
738:
739: if (recherche_variable(s_etat_processus,
740: (*((struct_fonction *)
741: (*(*l_element_courant).donnee).objet)).nom_fonction)
742: == d_faux)
743: {
744: (*s_etat_processus).erreur_systeme = d_es;
745: (*s_etat_processus).instruction_courante =
746: (*((struct_fonction *) (*(*l_element_courant)
747: .donnee).objet)).nom_fonction;
748:
749: registre_expression_courante =
750: (*s_etat_processus).expression_courante;
751: (*s_etat_processus).expression_courante = l_element_courant;
752:
753: if (((*s_etat_processus).erreur_execution == d_ex) &&
754: ((*s_etat_processus).erreur_systeme == d_es) &&
755: ((*s_etat_processus).exception == d_ep))
756: {
757: registre_evaluation_expression_compilee =
758: (*s_etat_processus)
759: .evaluation_expression_compilee;
760:
761: (*s_etat_processus).evaluation_expression_compilee
762: = 'Y';
763:
764: analyse(s_etat_processus, (*((struct_fonction *)
765: (*(*l_element_courant).donnee).objet))
766: .fonction);
767:
768: (*s_etat_processus).evaluation_expression_compilee =
769: registre_evaluation_expression_compilee;
770:
771: if (type_evaluation == 'I')
772: {
773: (*s_etat_processus).derniere_erreur_evaluation =
774: (*s_etat_processus).erreur_execution;
775: }
776: }
777:
778: if ((*s_etat_processus).erreur_systeme != d_es)
779: {
780: if (presence_egalite == d_vrai)
781: {
782: liberation(s_etat_processus, s_objet_evalue);
783: }
784:
785: if ((*s_etat_processus).var_volatile_processus_pere
786: == 0)
787: {
788: envoi_signal_processus((*s_etat_processus)
789: .pid_processus_pere, rpl_sigalrm);
790: }
791: else
792: {
793: (*s_etat_processus).var_volatile_alarme = -1;
794: }
795:
796: (*s_etat_processus).instruction_courante =
797: instruction_courante;
798: return(d_erreur);
799: }
800: else if (((*s_etat_processus).erreur_execution != d_ex) ||
801: ((*s_etat_processus).exception != d_ep))
802: {
803: if ((*s_etat_processus).arret_si_exception == d_faux)
804: {
805: /*
806: * Reprise sur erreur
807: */
808:
809: if ((message = messages(s_etat_processus)) == NULL)
810: {
811: if (presence_egalite == d_vrai)
812: {
813: liberation(s_etat_processus,
814: s_objet_evalue);
815: }
816:
817: (*s_etat_processus).instruction_courante =
818: instruction_courante;
819: return(d_erreur);
820: }
821:
822: free(message);
823:
824: drapeau_then = d_faux;
825:
826: while(drapeau_then == d_faux)
827: {
828: l_registre_atome = l_element_courant;
829: l_element_courant =
830: (*l_element_courant).suivant;
831:
832: if (l_element_courant == NULL)
833: {
834: /*
835: * La fin de l'expression est atteinte,
836: * le sequenceur reprend la main.
837: */
838:
839: if (presence_egalite == d_vrai)
840: {
841: liberation(s_etat_processus,
842: s_objet_evalue);
843: }
844:
845: (*s_etat_processus)
846: .mode_execution_programme =
847: registre_mode_execution_programme;
848: return(d_absence_erreur);
849: }
850:
851: if ((*(*l_element_courant).donnee).type == FCT)
852: {
853: (*s_etat_processus).instruction_courante =
854: (*((struct_fonction *)
855: (*(*l_element_courant).donnee)
856: .objet)).nom_fonction;
857:
858: if (recherche_variable(s_etat_processus,
859: (*s_etat_processus)
860: .instruction_courante) == d_faux)
861: {
862: (*s_etat_processus).erreur_systeme
863: = d_es;
864: fonction = (*((struct_fonction *)
865: (*(*l_element_courant).donnee)
866: .objet)).fonction;
867:
868: /*
869: * Traitement de la pile système par les
870: * différentes instructions.
871: */
872:
873: if (TEST(instruction_if) ||
874: TEST(instruction_iferr) ||
875: TEST(instruction_do) ||
876: TEST(instruction_while) ||
877: TEST(instruction_for) ||
878: TEST(instruction_forall) ||
879: TEST(instruction_start) ||
880: TEST(instruction_select) ||
881: TEST(instruction_case) ||
882: TEST(instruction_critical) ||
883: TEST(vers_niveau_superieur))
884: {
885: if (TEST(vers_niveau_superieur))
886: {
887: registre_exception =
888: (*s_etat_processus)
889: .exception;
890: registre_erreur_execution =
891: (*s_etat_processus)
892: .erreur_execution;
893:
894: analyse(s_etat_processus,
895: vers_niveau_superieur);
896:
897: if ((*s_etat_processus)
898: .erreur_systeme != d_es)
899: {
900: if (presence_egalite ==
901: d_vrai)
902: {
903: liberation(
904: s_etat_processus,
905: s_objet_evalue);
906: }
907:
908: (*s_etat_processus)
909: .instruction_courante =
910: instruction_courante;
911: return(d_erreur);
912: }
913:
914: (*s_etat_processus).exception
915: = registre_exception;
916: (*s_etat_processus)
917: .erreur_execution =
918: registre_erreur_execution;
919: }
920: else if (TEST(instruction_for) ||
921: TEST(instruction_forall) ||
922: TEST(instruction_start))
923: {
924: empilement_pile_systeme(
925: s_etat_processus);
926:
927: if ((*s_etat_processus)
928: .erreur_systeme != d_es)
929: {
930: if (presence_egalite ==
931: d_vrai)
932: {
933: liberation(
934: s_etat_processus,
935: s_objet_evalue);
936: }
937:
938: (*s_etat_processus)
939: .instruction_courante =
940: instruction_courante;
941: return(d_erreur);
942: }
943:
944: (*(*s_etat_processus)
945: .l_base_pile_systeme)
946: .type_cloture = 'L';
947: }
948: else
949: {
950: empilement_pile_systeme(
951: s_etat_processus);
952:
953: if ((*s_etat_processus)
954: .erreur_systeme != d_es)
955: {
956: if (presence_egalite ==
957: d_vrai)
958: {
959: liberation(
960: s_etat_processus,
961: s_objet_evalue);
962: }
963:
964: (*s_etat_processus)
965: .instruction_courante =
966: instruction_courante;
967: return(d_erreur);
968: }
969: }
970: }
971: else if (TEST(instruction_end) ||
972: TEST(instruction_next) ||
973: TEST(instruction_step) ||
974: TEST(vers_niveau_inferieur))
975: {
976: if (TEST(vers_niveau_inferieur))
977: {
978: registre_exception =
979: (*s_etat_processus)
980: .exception;
981: registre_erreur_execution =
982: (*s_etat_processus)
983: .erreur_execution;
984:
985: analyse(s_etat_processus,
986: vers_niveau_inferieur);
987:
988: if ((*s_etat_processus)
989: .erreur_systeme != d_es)
990: {
991: if (presence_egalite ==
992: d_vrai)
993: {
994: liberation(
995: s_etat_processus,
996: s_objet_evalue);
997: }
998:
999: (*s_etat_processus)
1000: .instruction_courante =
1001: instruction_courante;
1002: return(d_erreur);
1003: }
1004:
1005: (*s_etat_processus).exception
1006: = registre_exception;
1007: (*s_etat_processus)
1008: .erreur_execution =
1009: registre_erreur_execution;
1010: }
1011: else if ((TEST(instruction_next) ||
1012: TEST(instruction_step)) &&
1013: ((*(*s_etat_processus)
1014: .l_base_pile_systeme)
1015: .type_cloture != 'L'))
1016: {
1017: /*
1018: * Libération des compteurs
1019: * de boucle
1020: */
1021:
1022: presence_compteur =
1023: (((*(*s_etat_processus)
1024: .l_base_pile_systeme)
1025: .type_cloture == 'F') ||
1026: ((*(*s_etat_processus)
1027: .l_base_pile_systeme)
1028: .type_cloture == 'A'))
1029: ? d_vrai : d_faux;
1030:
1031: if (((*(*s_etat_processus)
1032: .l_base_pile_systeme)
1033: .type_cloture != 'S') &&
1034: (presence_compteur ==
1035: d_faux))
1036: {
1037: (*s_etat_processus)
1038: .erreur_execution =
1039: d_ex_erreur_traitement_boucle;
1040:
1041: if (presence_egalite ==
1042: d_vrai)
1043: {
1044: liberation(
1045: s_etat_processus,
1046: s_objet_evalue);
1047: }
1048:
1049: (*s_etat_processus)
1050: .instruction_courante =
1051: instruction_courante;
1052: return(d_erreur);
1053: }
1054:
1055: if (presence_compteur == d_vrai)
1056: {
1057: if (recherche_variable(
1058: s_etat_processus,
1059: (*(*s_etat_processus)
1060: .l_base_pile_systeme)
1061: .nom_variable) ==
1062: d_faux)
1063: {
1064: (*s_etat_processus)
1065: .erreur_systeme = d_es;
1066: (*s_etat_processus)
1067: .erreur_execution =
1068: d_ex_erreur_traitement_boucle;
1069:
1070: if (presence_egalite ==
1071: d_vrai)
1072: {
1073: liberation(
1074: s_etat_processus,
1075: s_objet_evalue);
1076: }
1077:
1078: (*s_etat_processus)
1079: .instruction_courante =
1080: instruction_courante;
1081: return(d_erreur);
1082: }
1083:
1084: if ((*(*s_etat_processus)
1085: .pointeur_variable_courante)
1086: .objet == NULL)
1087: {
1088: (*s_etat_processus)
1089: .erreur_systeme = d_es;
1090: (*s_etat_processus)
1091: .erreur_execution =
1092: d_ex_variable_partagee;
1093:
1094: if (presence_egalite ==
1095: d_vrai)
1096: {
1097: liberation(
1098: s_etat_processus,
1099: s_objet_evalue);
1100: }
1101:
1102: (*s_etat_processus)
1103: .instruction_courante =
1104: instruction_courante;
1105: return(d_erreur);
1106: }
1107:
1108: (*s_etat_processus)
1109: .niveau_courant--;
1110:
1111: if (
1112: retrait_variables_par_niveau(
1113: s_etat_processus) == d_erreur)
1114: {
1115: if (presence_egalite ==
1116: d_vrai)
1117: {
1118: liberation(
1119: s_etat_processus,
1120: s_objet_evalue);
1121: }
1122:
1123: (*s_etat_processus)
1124: .instruction_courante =
1125: instruction_courante;
1126: return(d_erreur);
1127: }
1128: }
1129:
1130: depilement_pile_systeme(
1131: s_etat_processus);
1132: }
1133: else
1134: {
1135: // Traitement spécifique pour
1136: // la fin d'une section
1137: // critique
1138:
1139: if ((*s_etat_processus)
1140: .l_base_pile_systeme
1141: == NULL)
1142: {
1143: (*s_etat_processus)
1144: .erreur_systeme =
1145: d_es_end_incoherent;
1146:
1147: if (presence_egalite ==
1148: d_vrai)
1149: {
1150: liberation(
1151: s_etat_processus,
1152: s_objet_evalue);
1153: }
1154:
1155: (*s_etat_processus)
1156: .instruction_courante =
1157: instruction_courante;
1158: return(d_erreur);
1159: }
1160:
1161: if ((*(*s_etat_processus)
1162: .l_base_pile_systeme)
1163: .type_cloture == 'Q')
1164: {
1165: if (pthread_mutex_unlock(
1166: &mutex_sections_critiques)
1167: != 0)
1168: {
1169: (*s_etat_processus)
1170: .erreur_systeme =
1171: d_es_processus;
1172:
1173: liberation(
1174: s_etat_processus,
1175: s_objet_evalue);
1176:
1177: (*s_etat_processus)
1178: .instruction_courante =
1179: instruction_courante;
1180: return(d_erreur);
1181: }
1182:
1183: (*s_etat_processus)
1184: .sections_critiques--;
1185: }
1186:
1187: depilement_pile_systeme(
1188: s_etat_processus);
1189:
1190: if ((*s_etat_processus)
1191: .erreur_systeme != d_es)
1192: {
1193: if (presence_egalite ==
1194: d_vrai)
1195: {
1196: liberation(
1197: s_etat_processus,
1198: s_objet_evalue);
1199: }
1200:
1201: (*s_etat_processus)
1202: .instruction_courante =
1203: instruction_courante;
1204: return(d_erreur);
1205: }
1206: }
1207: }
1208: else if (TEST(instruction_then))
1209: {
1210: if ((*(*s_etat_processus)
1211: .l_base_pile_systeme)
1212: .clause == 'R')
1213: {
1214: (*(*s_etat_processus)
1215: .l_base_pile_systeme)
1216: .clause = 'X';
1217: instruction_then(
1218: s_etat_processus);
1219: drapeau_then = d_vrai;
1220: }
1221: }
1222: }
1223: }
1224: }
1225:
1226: (*s_etat_processus).expression_courante =
1227: l_element_courant;
1228: (*s_etat_processus).instruction_courante =
1229: instruction_courante;
1230:
1231: (*s_etat_processus).exception = d_ep;
1232: (*s_etat_processus).erreur_execution = d_ex;
1233: }
1234: else if ((*s_etat_processus).mode_evaluation_expression
1235: == 'Y')
1236: {
1237: /*
1238: * Reprise sur erreur
1239: */
1240:
1241: while(l_element_courant != NULL)
1242: {
1243: if ((*(*l_element_courant).donnee).type == FCT)
1244: {
1245: (*s_etat_processus).instruction_courante =
1246: (*((struct_fonction *)
1247: (*(*l_element_courant).donnee)
1248: .objet)).nom_fonction;
1249: fonction = (*((struct_fonction *)
1250: (*(*l_element_courant).donnee)
1251: .objet)).fonction;
1252:
1253: if (recherche_variable(s_etat_processus,
1254: (*s_etat_processus)
1255: .instruction_courante) == d_faux)
1256: {
1257: (*s_etat_processus).erreur_systeme
1258: = d_es;
1259:
1260: /*
1261: * Traitement de la pile système par les
1262: * différentes instructions.
1263: */
1264:
1265: if (TEST(instruction_if) ||
1266: TEST(instruction_iferr) ||
1267: TEST(instruction_do) ||
1268: TEST(instruction_while) ||
1269: TEST(instruction_for) ||
1270: TEST(instruction_forall) ||
1271: TEST(instruction_start) ||
1272: TEST(instruction_select) ||
1273: TEST(instruction_case) ||
1274: TEST(instruction_critical) ||
1275: TEST(vers_niveau_superieur))
1276: {
1277: if (TEST(vers_niveau_superieur))
1278: {
1279: analyse(s_etat_processus,
1280: vers_niveau_superieur);
1281:
1282: if ((*s_etat_processus)
1283: .erreur_systeme != d_es)
1284: {
1285: if (presence_egalite ==
1286: d_vrai)
1287: {
1288: liberation(
1289: s_etat_processus,
1290: s_objet_evalue);
1291: }
1292:
1293: (*s_etat_processus)
1294: .instruction_courante =
1295: instruction_courante;
1296: return(d_erreur);
1297: }
1298: }
1299: else if (TEST(instruction_for) ||
1300: TEST(instruction_forall) ||
1301: TEST(instruction_start))
1302: {
1303: empilement_pile_systeme(
1304: s_etat_processus);
1305:
1306: if ((*s_etat_processus)
1307: .erreur_systeme != d_es)
1308: {
1309: if (presence_egalite ==
1310: d_vrai)
1311: {
1312: liberation(
1313: s_etat_processus,
1314: s_objet_evalue);
1315: }
1316:
1317: (*s_etat_processus)
1318: .instruction_courante =
1319: instruction_courante;
1320: return(d_erreur);
1321: }
1322:
1323: (*(*s_etat_processus)
1324: .l_base_pile_systeme)
1325: .type_cloture = 'L';
1326: }
1327: else
1328: {
1329: empilement_pile_systeme(
1330: s_etat_processus);
1331:
1332: if ((*s_etat_processus)
1333: .erreur_systeme != d_es)
1334: {
1335: if (presence_egalite ==
1336: d_vrai)
1337: {
1338: liberation(
1339: s_etat_processus,
1340: s_objet_evalue);
1341: }
1342:
1343: (*s_etat_processus)
1344: .instruction_courante =
1345: instruction_courante;
1346: return(d_erreur);
1347: }
1348: }
1349: }
1350: else if (TEST(instruction_end) ||
1351: TEST(instruction_next) ||
1352: TEST(instruction_step) ||
1353: TEST(vers_niveau_inferieur))
1354: {
1355: if (TEST(vers_niveau_inferieur))
1356: {
1357: analyse(s_etat_processus,
1358: vers_niveau_inferieur);
1359:
1360: if ((*s_etat_processus)
1361: .erreur_systeme != d_es)
1362: {
1363: if (presence_egalite ==
1364: d_vrai)
1365: {
1366: liberation(
1367: s_etat_processus,
1368: s_objet_evalue);
1369: }
1370:
1371: (*s_etat_processus)
1372: .instruction_courante =
1373: instruction_courante;
1374: return(d_erreur);
1375: }
1376: }
1377: else if ((TEST(instruction_next) ||
1378: TEST(instruction_step)) &&
1379: ((*(*s_etat_processus)
1380: .l_base_pile_systeme)
1381: .type_cloture != 'L'))
1382: {
1383: /*
1384: * Libération des compteurs
1385: * de boucle
1386: */
1387:
1388: presence_compteur =
1389: (((*(*s_etat_processus)
1390: .l_base_pile_systeme)
1391: .type_cloture == 'F') ||
1392: ((*(*s_etat_processus)
1393: .l_base_pile_systeme)
1394: .type_cloture == 'A'))
1395: ? d_vrai : d_faux;
1396:
1397: if (((*(*s_etat_processus)
1398: .l_base_pile_systeme)
1399: .type_cloture != 'S') &&
1400: (presence_compteur ==
1401: d_faux))
1402: {
1403: (*s_etat_processus)
1404: .erreur_execution =
1405: d_ex_erreur_traitement_boucle;
1406:
1407: if (presence_egalite ==
1408: d_vrai)
1409: {
1410: liberation(
1411: s_etat_processus,
1412: s_objet_evalue);
1413: }
1414:
1415: (*s_etat_processus)
1416: .instruction_courante =
1417: instruction_courante;
1418: return(d_erreur);
1419: }
1420:
1421: if (presence_compteur == d_vrai)
1422: {
1423: if (recherche_variable(
1424: s_etat_processus,
1425: (*(*s_etat_processus)
1426: .l_base_pile_systeme)
1427: .nom_variable) ==
1428: d_faux)
1429: {
1430: (*s_etat_processus)
1431: .erreur_systeme = d_es;
1432: (*s_etat_processus)
1433: .erreur_execution =
1434: d_ex_erreur_traitement_boucle;
1435:
1436: if (presence_egalite ==
1437: d_vrai)
1438: {
1439: liberation(
1440: s_etat_processus,
1441: s_objet_evalue);
1442: }
1443:
1444: (*s_etat_processus)
1445: .instruction_courante =
1446: instruction_courante;
1447: return(d_erreur);
1448: }
1449:
1450: if ((*(*s_etat_processus)
1451: .pointeur_variable_courante)
1452: .objet == NULL)
1453: {
1454: (*s_etat_processus)
1455: .erreur_systeme = d_es;
1456: (*s_etat_processus)
1457: .erreur_execution =
1458: d_ex_variable_partagee;
1459:
1460: if (presence_egalite ==
1461: d_vrai)
1462: {
1463: liberation(
1464: s_etat_processus,
1465: s_objet_evalue);
1466: }
1467:
1468: (*s_etat_processus)
1469: .instruction_courante =
1470: instruction_courante;
1471: return(d_erreur);
1472: }
1473:
1474: (*s_etat_processus)
1475: .niveau_courant--;
1476:
1477: if (
1478: retrait_variables_par_niveau(
1479: s_etat_processus) == d_erreur)
1480: {
1481: if (presence_egalite ==
1482: d_vrai)
1483: {
1484: liberation(
1485: s_etat_processus,
1486: s_objet_evalue);
1487: }
1488:
1489: (*s_etat_processus)
1490: .instruction_courante =
1491: instruction_courante;
1492: return(d_erreur);
1493: }
1494: }
1495:
1496: depilement_pile_systeme(
1497: s_etat_processus);
1498: }
1499: else
1500: {
1501: // Traitement spécifique pour
1502: // la fin d'une section
1503: // critique
1504:
1505: if ((*s_etat_processus)
1506: .l_base_pile_systeme
1507: == NULL)
1508: {
1509: (*s_etat_processus)
1510: .erreur_systeme =
1511: d_es_end_incoherent;
1512:
1513: if (presence_egalite ==
1514: d_vrai)
1515: {
1516: liberation(
1517: s_etat_processus,
1518: s_objet_evalue);
1519: }
1520:
1521: (*s_etat_processus)
1522: .instruction_courante =
1523: instruction_courante;
1524: return(d_erreur);
1525: }
1526:
1527: if ((*(*s_etat_processus)
1528: .l_base_pile_systeme)
1529: .type_cloture == 'Q')
1530: {
1531: if (pthread_mutex_unlock(
1532: &mutex_sections_critiques)
1533: != 0)
1534: {
1535: (*s_etat_processus)
1536: .erreur_systeme =
1537: d_es_processus;
1538:
1539: if (presence_egalite ==
1540: d_vrai)
1541: {
1542: liberation(
1543: s_etat_processus,
1544: s_objet_evalue);
1545: }
1546:
1547: (*s_etat_processus)
1548: .instruction_courante =
1549: instruction_courante;
1550: return(d_erreur);
1551: }
1552:
1553: (*s_etat_processus)
1554: .sections_critiques--;
1555: }
1556:
1557: depilement_pile_systeme(
1558: s_etat_processus);
1559: }
1560:
1561: if ((*s_etat_processus)
1562: .erreur_systeme != d_es)
1563: {
1564: if (presence_egalite ==
1565: d_vrai)
1566: {
1567: liberation(
1568: s_etat_processus,
1569: s_objet_evalue);
1570: }
1571:
1572: (*s_etat_processus)
1573: .instruction_courante =
1574: instruction_courante;
1575: return(d_erreur);
1576: }
1577: }
1578: }
1579: }
1580:
1581: l_element_courant =
1582: (*l_element_courant).suivant;
1583: }
1584:
1585: (*s_etat_processus).mode_execution_programme =
1586: registre_mode_execution_programme;
1587: (*s_etat_processus).instruction_courante =
1588: instruction_courante;
1589:
1590: (*s_etat_processus).exception = d_ep;
1591: (*s_etat_processus).erreur_execution = d_ex;
1592:
1593: erreur_evaluation = d_erreur;
1594:
1595: (*s_etat_processus).expression_courante =
1596: registre_expression_courante;
1597: }
1598: else
1599: {
1600: // On ne détruit pas les variables pour les inclure
1601: // dans le fichier rpl-core.
1602:
1603: (*s_etat_processus).gel_liste_variables = d_vrai;
1604:
1605: registre_erreur_execution =
1606: (*s_etat_processus).erreur_execution;
1607: registre_exception =
1608: (*s_etat_processus).exception;
1609: registre_erreur_systeme =
1610: (*s_etat_processus).erreur_systeme;
1611:
1612: (*s_etat_processus).s_objet_errone = s_objet;
1613: (*s_etat_processus).s_objet_erreur =
1614: (*l_element_courant).donnee;
1615:
1616: l_element_courant = (*l_element_courant).suivant;
1617:
1618: while(l_element_courant != NULL)
1619: {
1620: if ((*(*l_element_courant).donnee).type == FCT)
1621: {
1622: (*s_etat_processus).instruction_courante =
1623: (*((struct_fonction *)
1624: (*(*l_element_courant).donnee)
1625: .objet)).nom_fonction;
1626: fonction = (*((struct_fonction *)
1627: (*(*l_element_courant).donnee)
1628: .objet)).fonction;
1629:
1630: if (recherche_variable(s_etat_processus,
1631: (*s_etat_processus)
1632: .instruction_courante) == d_faux)
1633: {
1634: (*s_etat_processus).erreur_systeme
1635: = d_es;
1636:
1637: /*
1638: * Traitement de la pile système par les
1639: * différentes instructions.
1640: */
1641:
1642: if (TEST(instruction_if) ||
1643: TEST(instruction_iferr) ||
1644: TEST(instruction_do) ||
1645: TEST(instruction_while) ||
1646: TEST(instruction_for) ||
1647: TEST(instruction_forall) ||
1648: TEST(instruction_start) ||
1649: TEST(instruction_select) ||
1650: TEST(instruction_case) ||
1651: TEST(instruction_critical) ||
1652: TEST(vers_niveau_superieur))
1653: {
1654: if (TEST(vers_niveau_superieur))
1655: {
1656: analyse(s_etat_processus,
1657: vers_niveau_superieur);
1658:
1659: if ((*s_etat_processus)
1660: .erreur_systeme != d_es)
1661: {
1662: if (presence_egalite ==
1663: d_vrai)
1664: {
1665: liberation(
1666: s_etat_processus,
1667: s_objet_evalue);
1668: }
1669:
1670: (*s_etat_processus)
1671: .instruction_courante =
1672: instruction_courante;
1673: return(d_erreur);
1674: }
1675: }
1676: else if (TEST(instruction_for) ||
1677: TEST(instruction_forall) ||
1678: TEST(instruction_start))
1679: {
1680: empilement_pile_systeme(
1681: s_etat_processus);
1682:
1683: if ((*s_etat_processus)
1684: .erreur_systeme != d_es)
1685: {
1686: if (presence_egalite ==
1687: d_vrai)
1688: {
1689: liberation(
1690: s_etat_processus,
1691: s_objet_evalue);
1692: }
1693:
1694: (*s_etat_processus)
1695: .instruction_courante =
1696: instruction_courante;
1697: return(d_erreur);
1698: }
1699:
1700: (*(*s_etat_processus)
1701: .l_base_pile_systeme)
1702: .type_cloture = 'L';
1703: }
1704: else
1705: {
1706: empilement_pile_systeme(
1707: s_etat_processus);
1708:
1709: if ((*s_etat_processus)
1710: .erreur_systeme != d_es)
1711: {
1712: if (presence_egalite ==
1713: d_vrai)
1714: {
1715: liberation(
1716: s_etat_processus,
1717: s_objet_evalue);
1718: }
1719:
1720: (*s_etat_processus)
1721: .instruction_courante =
1722: instruction_courante;
1723: return(d_erreur);
1724: }
1725: }
1726: }
1727: else if (TEST(instruction_end) ||
1728: TEST(instruction_next) ||
1729: TEST(instruction_step) ||
1730: TEST(vers_niveau_inferieur))
1731: {
1732: if (TEST(vers_niveau_inferieur))
1733: {
1734: analyse(s_etat_processus,
1735: vers_niveau_inferieur);
1736:
1737: if ((*s_etat_processus)
1738: .erreur_systeme != d_es)
1739: {
1740: if (presence_egalite ==
1741: d_vrai)
1742: {
1743: liberation(
1744: s_etat_processus,
1745: s_objet_evalue);
1746: }
1747:
1748: (*s_etat_processus)
1749: .instruction_courante =
1750: instruction_courante;
1751: return(d_erreur);
1752: }
1753:
1754: if ((*(*s_etat_processus)
1755: .l_base_pile_systeme)
1756: .retour_definition
1757: == 'Y')
1758: {
1759: break;
1760: }
1761: }
1762: else if ((TEST(instruction_next) ||
1763: TEST(instruction_step)) &&
1764: ((*(*s_etat_processus)
1765: .l_base_pile_systeme)
1766: .type_cloture != 'L'))
1767: {
1768: /*
1769: * Libération des compteurs
1770: * de boucle
1771: */
1772:
1773: presence_compteur =
1774: (((*(*s_etat_processus)
1775: .l_base_pile_systeme)
1776: .type_cloture == 'F') ||
1777: ((*(*s_etat_processus)
1778: .l_base_pile_systeme)
1779: .type_cloture == 'A'))
1780: ? d_vrai : d_faux;
1781:
1782: if (((*(*s_etat_processus)
1783: .l_base_pile_systeme)
1784: .type_cloture != 'S') &&
1785: (presence_compteur ==
1786: d_faux))
1787: {
1788: (*s_etat_processus)
1789: .erreur_execution =
1790: d_ex_erreur_traitement_boucle;
1791:
1792: if (presence_egalite ==
1793: d_vrai)
1794: {
1795: liberation(
1796: s_etat_processus,
1797: s_objet_evalue);
1798: }
1799:
1800: (*s_etat_processus)
1801: .instruction_courante =
1802: instruction_courante;
1803: return(d_erreur);
1804: }
1805:
1806: if (presence_compteur == d_vrai)
1807: {
1808: if (recherche_variable(
1809: s_etat_processus,
1810: (*(*s_etat_processus)
1811: .l_base_pile_systeme)
1812: .nom_variable) ==
1813: d_faux)
1814: {
1815: (*s_etat_processus)
1816: .erreur_systeme = d_es;
1817: (*s_etat_processus)
1818: .erreur_execution =
1819: d_ex_erreur_traitement_boucle;
1820:
1821: if (presence_egalite ==
1822: d_vrai)
1823: {
1824: liberation(
1825: s_etat_processus,
1826: s_objet_evalue);
1827: }
1828:
1829: (*s_etat_processus)
1830: .instruction_courante =
1831: instruction_courante;
1832: return(d_erreur);
1833: }
1834:
1835: if ((*(*s_etat_processus)
1836: .pointeur_variable_courante)
1837: .objet == NULL)
1838: {
1839: (*s_etat_processus)
1840: .erreur_systeme = d_es;
1841: (*s_etat_processus)
1842: .erreur_execution =
1843: d_ex_variable_partagee;
1844:
1845: if (presence_egalite ==
1846: d_vrai)
1847: {
1848: liberation(
1849: s_etat_processus,
1850: s_objet_evalue);
1851: }
1852:
1853: (*s_etat_processus)
1854: .instruction_courante =
1855: instruction_courante;
1856: return(d_erreur);
1857: }
1858:
1859: (*s_etat_processus)
1860: .niveau_courant--;
1861:
1862: if (
1863: retrait_variables_par_niveau(
1864: s_etat_processus) == d_erreur)
1865: {
1866: if (presence_egalite ==
1867: d_vrai)
1868: {
1869: liberation(
1870: s_etat_processus,
1871: s_objet_evalue);
1872: }
1873:
1874: (*s_etat_processus)
1875: .instruction_courante =
1876: instruction_courante;
1877: return(d_erreur);
1878: }
1879: }
1880:
1881: depilement_pile_systeme(
1882: s_etat_processus);
1883: }
1884: else
1885: {
1886: // Traitement spécifique pour
1887: // la fin d'une section critique
1888:
1889: if ((*s_etat_processus)
1890: .l_base_pile_systeme
1891: == NULL)
1892: {
1893: (*s_etat_processus)
1894: .erreur_systeme =
1895: d_es_end_incoherent;
1896:
1897: if (presence_egalite ==
1898: d_vrai)
1899: {
1900: liberation(
1901: s_etat_processus,
1902: s_objet_evalue);
1903: }
1904:
1905: (*s_etat_processus)
1906: .instruction_courante =
1907: instruction_courante;
1908: return(d_erreur);
1909: }
1910:
1911: if ((*(*s_etat_processus)
1912: .l_base_pile_systeme)
1913: .type_cloture == 'Q')
1914: {
1915: if (pthread_mutex_unlock(
1916: &mutex_sections_critiques)
1917: != 0)
1918: {
1919: (*s_etat_processus)
1920: .erreur_systeme =
1921: d_es_processus;
1922:
1923: if (presence_egalite ==
1924: d_vrai)
1925: {
1926: liberation(
1927: s_etat_processus,
1928: s_objet_evalue);
1929: }
1930:
1931: (*s_etat_processus)
1932: .instruction_courante =
1933: instruction_courante;
1934: return(d_erreur);
1935: }
1936:
1937: (*s_etat_processus)
1938: .sections_critiques--;
1939: }
1940:
1941: depilement_pile_systeme(
1942: s_etat_processus);
1943:
1944: if ((*s_etat_processus)
1945: .erreur_systeme != d_es)
1946: {
1947: if (presence_egalite ==
1948: d_vrai)
1949: {
1950: liberation(
1951: s_etat_processus,
1952: s_objet_evalue);
1953: }
1954:
1955: (*s_etat_processus)
1956: .instruction_courante =
1957: instruction_courante;
1958: return(d_erreur);
1959: }
1960: }
1961: }
1962: }
1963: }
1964:
1965: l_element_courant =
1966: (*l_element_courant).suivant;
1967: }
1968:
1969: (*s_etat_processus).mode_execution_programme =
1970: registre_mode_execution_programme;
1971: (*s_etat_processus).instruction_courante =
1972: instruction_courante;
1973:
1974: if (presence_egalite == d_vrai)
1975: {
1976: liberation(s_etat_processus, s_objet_evalue);
1977: }
1978:
1979: if ((*s_etat_processus)
1980: .var_volatile_processus_pere == 0)
1981: {
1982: envoi_signal_processus((*s_etat_processus)
1983: .pid_processus_pere, rpl_sigalrm);
1984: }
1985: else
1986: {
1987: (*s_etat_processus).var_volatile_alarme = -1;
1988: }
1989:
1990: (*s_etat_processus).erreur_execution =
1991: registre_erreur_execution;
1992: (*s_etat_processus).erreur_systeme =
1993: registre_erreur_systeme;
1994: (*s_etat_processus).exception =
1995: registre_exception;
1996: return(d_erreur);
1997: }
1998: }
1999:
2000: if ((*s_etat_processus).instruction_valide == 'Y')
2001: {
2002: l_element_courant = (*s_etat_processus)
2003: .expression_courante;
2004: }
2005: else
2006: {
2007: /*
2008: * Régénération de la fonction en notation algébrique
2009: */
2010:
2011: if ((s_objet_elementaire = (struct_objet *)
2012: allocation(s_etat_processus, ALG)) == NULL)
2013: {
2014: if (presence_egalite == d_vrai)
2015: {
2016: liberation(s_etat_processus, s_objet_evalue);
2017: }
2018:
2019: (*s_etat_processus).erreur_systeme =
2020: d_es_allocation_memoire;
2021: (*s_etat_processus).instruction_courante =
2022: instruction_courante;
2023: return(d_erreur);
2024: }
2025:
2026: /*
2027: * Ouverture de l'expression
2028: */
2029:
2030: if (((*s_objet_elementaire).objet =
2031: (struct_liste_chainee *)
2032: malloc(sizeof(struct_liste_chainee))) == NULL)
2033: {
2034: if (presence_egalite == d_vrai)
2035: {
2036: liberation(s_etat_processus, s_objet_evalue);
2037: }
2038:
2039: (*s_etat_processus).erreur_systeme =
2040: d_es_allocation_memoire;
2041: (*s_etat_processus).instruction_courante =
2042: instruction_courante;
2043: return(d_erreur);
2044: }
2045:
2046: l_element_fonction = (*s_objet_elementaire).objet;
2047:
2048: if (((*l_element_fonction).donnee = (struct_objet *)
2049: allocation(s_etat_processus, FCT)) == NULL)
2050: {
2051: if (presence_egalite == d_vrai)
2052: {
2053: liberation(s_etat_processus, s_objet_evalue);
2054: }
2055:
2056: (*s_etat_processus).erreur_systeme =
2057: d_es_allocation_memoire;
2058: (*s_etat_processus).instruction_courante =
2059: instruction_courante;
2060: return(d_erreur);
2061: }
2062:
2063: (*((struct_fonction *) (*(*l_element_fonction).donnee)
2064: .objet)).nombre_arguments = 0;
2065: (*((struct_fonction *) (*(*l_element_fonction).donnee)
2066: .objet)).fonction =
2067: instruction_vers_niveau_superieur;
2068:
2069: if (((*((struct_fonction *) (*(*l_element_fonction)
2070: .donnee).objet)).nom_fonction =
2071: (unsigned char *) malloc(3 * sizeof(
2072: unsigned char))) == NULL)
2073: {
2074: if (presence_egalite == d_vrai)
2075: {
2076: liberation(s_etat_processus, s_objet_evalue);
2077: }
2078:
2079: (*s_etat_processus).erreur_systeme =
2080: d_es_allocation_memoire;
2081: (*s_etat_processus).instruction_courante =
2082: instruction_courante;
2083: return(d_erreur);
2084: }
2085:
2086: strcpy((*((struct_fonction *) (*(*l_element_fonction)
2087: .donnee).objet)).nom_fonction, "<<");
2088:
2089: /*
2090: * Ajout des arguments
2091: */
2092:
2093: for(k = (*((struct_fonction *)
2094: (*(*l_element_courant).donnee).objet))
2095: .nombre_arguments; k >= 1; k--)
2096: {
2097: if (((*l_element_fonction).suivant =
2098: (struct_liste_chainee *) malloc(sizeof(
2099: struct_liste_chainee))) == NULL)
2100: {
2101: if (presence_egalite == d_vrai)
2102: {
2103: liberation(s_etat_processus,
2104: s_objet_evalue);
2105: }
2106:
2107: (*s_etat_processus).erreur_systeme =
2108: d_es_allocation_memoire;
2109: (*s_etat_processus).instruction_courante =
2110: instruction_courante;
2111: return(d_erreur);
2112: }
2113:
2114: l_element_fonction = (*l_element_fonction).suivant;
2115:
2116: if (k > 1)
2117: {
2118: l_liste1 = (*s_etat_processus).l_base_pile;
2119:
2120: for(l = 2; l < k; l++)
2121: {
2122: l_liste1 = (*l_liste1).suivant;
2123: }
2124:
2125: l_liste2 = (*l_liste1).suivant;
2126: (*l_liste1).suivant = (*l_liste2).suivant;
2127: (*l_liste2).suivant = (*s_etat_processus)
2128: .l_base_pile;
2129: (*s_etat_processus).l_base_pile = l_liste2;
2130: }
2131:
2132: if (depilement(s_etat_processus,
2133: &((*s_etat_processus).l_base_pile),
2134: &s_sous_objet) == d_erreur)
2135: {
2136: if (presence_egalite == d_vrai)
2137: {
2138: liberation(s_etat_processus,
2139: s_objet_evalue);
2140: }
2141:
2142: (*s_etat_processus).erreur_execution =
2143: d_ex_manque_argument;
2144: (*s_etat_processus).instruction_courante =
2145: instruction_courante;
2146: (*s_etat_processus).mode_execution_programme =
2147: registre_mode_execution_programme;
2148: return(d_erreur);
2149: }
2150:
2151: (*l_element_fonction).donnee = s_sous_objet;
2152: }
2153:
2154: /*
2155: * Ajout de la fonction
2156: */
2157:
2158: if (((*l_element_fonction).suivant =
2159: (struct_liste_chainee *) malloc(sizeof(
2160: struct_liste_chainee))) == NULL)
2161: {
2162: if (presence_egalite == d_vrai)
2163: {
2164: liberation(s_etat_processus, s_objet_evalue);
2165: }
2166:
2167: (*s_etat_processus).erreur_systeme =
2168: d_es_allocation_memoire;
2169: (*s_etat_processus).instruction_courante =
2170: instruction_courante;
2171: return(d_erreur);
2172: }
2173:
2174: l_element_fonction = (*l_element_fonction).suivant;
2175:
2176: if (((*l_element_fonction).donnee =
2177: copie_objet(s_etat_processus,
2178: (*l_element_courant).donnee, 'P'))
2179: == NULL)
2180: {
2181: if (presence_egalite == d_vrai)
2182: {
2183: liberation(s_etat_processus, s_objet_evalue);
2184: }
2185:
2186: (*s_etat_processus).erreur_systeme =
2187: d_es_allocation_memoire;
2188: (*s_etat_processus).instruction_courante =
2189: instruction_courante;
2190: return(d_erreur);
2191: }
2192:
2193: /*
2194: * Clôture de l'expression
2195: */
2196:
2197: if (((*l_element_fonction).suivant =
2198: (struct_liste_chainee *) malloc(sizeof(
2199: struct_liste_chainee))) == NULL)
2200: {
2201: if (presence_egalite == d_vrai)
2202: {
2203: liberation(s_etat_processus, s_objet_evalue);
2204: }
2205:
2206: (*s_etat_processus).erreur_systeme =
2207: d_es_allocation_memoire;
2208: (*s_etat_processus).instruction_courante =
2209: instruction_courante;
2210: return(d_erreur);
2211: }
2212:
2213: l_element_fonction = (*l_element_fonction).suivant;
2214:
2215: if (((*l_element_fonction).donnee =
2216: allocation(s_etat_processus, FCT)) == NULL)
2217: {
2218: if (presence_egalite == d_vrai)
2219: {
2220: liberation(s_etat_processus, s_objet_evalue);
2221: }
2222:
2223: (*s_etat_processus).erreur_systeme =
2224: d_es_allocation_memoire;
2225: (*s_etat_processus).instruction_courante =
2226: instruction_courante;
2227: return(d_erreur);
2228: }
2229:
2230: (*((struct_fonction *) (*(*l_element_fonction).donnee)
2231: .objet)).nombre_arguments = 0;
2232: (*((struct_fonction *) (*(*l_element_fonction).donnee)
2233: .objet)).fonction =
2234: instruction_vers_niveau_inferieur;
2235:
2236: if (((*((struct_fonction *) (*(*l_element_fonction)
2237: .donnee).objet)).nom_fonction =
2238: (unsigned char *) malloc(3 * sizeof(
2239: unsigned char))) == NULL)
2240: {
2241: if (presence_egalite == d_vrai)
2242: {
2243: liberation(s_etat_processus, s_objet_evalue);
2244: }
2245:
2246: (*s_etat_processus).erreur_systeme =
2247: d_es_allocation_memoire;
2248: (*s_etat_processus).instruction_courante =
2249: instruction_courante;
2250: return(d_erreur);
2251: }
2252:
2253: strcpy((*((struct_fonction *) (*(*l_element_fonction)
2254: .donnee).objet)).nom_fonction, ">>");
2255:
2256: (*l_element_fonction).suivant = NULL;
2257:
2258: if (empilement(s_etat_processus, &((*s_etat_processus)
2259: .l_base_pile), s_objet_elementaire) ==
2260: d_erreur)
2261: {
2262: if (presence_egalite == d_vrai)
2263: {
2264: liberation(s_etat_processus, s_objet_evalue);
2265: }
2266:
2267: (*s_etat_processus).instruction_courante =
2268: instruction_courante;
2269: return(d_erreur);
2270: }
2271: }
2272:
2273: (*s_etat_processus).expression_courante =
2274: registre_expression_courante;
2275: }
2276: else
2277: {
2278: if ((s_objet_elementaire =
2279: allocation(s_etat_processus, NON)) == NULL)
2280: {
2281: if (presence_egalite == d_vrai)
2282: {
2283: liberation(s_etat_processus, s_objet_evalue);
2284: }
2285:
2286: (*s_etat_processus).erreur_systeme =
2287: d_es_allocation_memoire;
2288: (*s_etat_processus).instruction_courante =
2289: instruction_courante;
2290: return(d_erreur);
2291: }
2292:
2293: if ((*(*s_etat_processus).pointeur_variable_courante).objet
2294: == NULL)
2295: {
2296: if (recherche_variable_partagee(s_etat_processus,
2297: (*(*s_etat_processus)
2298: .pointeur_variable_courante).nom,
2299: (*(*s_etat_processus)
2300: .pointeur_variable_courante).variable_partagee,
2301: 'E') != NULL)
2302: {
2303: // Une variable partagée existe.
2304:
2305: presence_variable_partagee = d_vrai;
2306:
2307: (*(*s_etat_processus).pointeur_variable_courante)
2308: .objet = (*(*s_etat_processus)
2309: .pointeur_variable_partagee_courante)
2310: .objet;
2311: }
2312: else
2313: {
2314: presence_variable_partagee = d_faux;
2315: }
2316: }
2317: else
2318: {
2319: presence_variable_partagee = d_faux;
2320: }
2321:
2322: /*
2323: * Recherche d'un élément dans un vecteur
2324: */
2325:
2326: if ((*(*s_etat_processus).pointeur_variable_courante)
2327: .objet == NULL)
2328: {
2329: // La variable partagée n'existe plus.
2330:
2331: free(s_objet_elementaire);
2332:
2333: if ((s_objet_elementaire =
2334: copie_objet(s_etat_processus,
2335: (*l_element_courant).donnee, 'P')) == NULL)
2336: {
2337: if (presence_variable_partagee == d_vrai)
2338: {
2339: (*(*s_etat_processus)
2340: .pointeur_variable_courante).objet =
2341: NULL;
2342:
2343: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2344: .pointeur_variable_partagee_courante)
2345: .mutex)) != 0)
2346: {
2347: (*s_etat_processus).erreur_systeme =
2348: d_es_processus;
2349: }
2350: }
2351:
2352: (*s_etat_processus).erreur_systeme =
2353: d_es_allocation_memoire;
2354: return(d_erreur);;
2355: }
2356: }
2357: else if ((((*((*(*s_etat_processus)
2358: .pointeur_variable_courante).objet)).type == VIN) ||
2359: ((*((*(*s_etat_processus)
2360: .pointeur_variable_courante).objet)).type == VRL) ||
2361: ((*((*(*s_etat_processus)
2362: .pointeur_variable_courante).objet)).type == VCX))
2363: && ((*((struct_fonction *) (*(*l_element_courant)
2364: .donnee).objet)).nombre_arguments == 1))
2365: {
2366: if (depilement(s_etat_processus, &((*s_etat_processus)
2367: .l_base_pile), &s_objet_indice_i) == d_erreur)
2368: {
2369: free(s_objet_elementaire);
2370:
2371: if (presence_variable_partagee == d_vrai)
2372: {
2373: (*(*s_etat_processus)
2374: .pointeur_variable_courante).objet =
2375: NULL;
2376:
2377: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2378: .pointeur_variable_partagee_courante)
2379: .mutex)) != 0)
2380: {
2381: (*s_etat_processus).erreur_systeme =
2382: d_es_processus;
2383: }
2384: }
2385:
2386: if (presence_egalite == d_vrai)
2387: {
2388: liberation(s_etat_processus, s_objet_evalue);
2389: }
2390:
2391: (*s_etat_processus).erreur_execution =
2392: d_ex_manque_argument;
2393: (*s_etat_processus).instruction_courante =
2394: instruction_courante;
2395: (*s_etat_processus).mode_execution_programme =
2396: registre_mode_execution_programme;
2397: return(d_erreur);
2398: }
2399:
2400: if ((*s_objet_indice_i).type != INT)
2401: {
2402: liberation(s_etat_processus, s_objet_indice_i);
2403: free(s_objet_elementaire);
2404:
2405: if (presence_variable_partagee == d_vrai)
2406: {
2407: (*(*s_etat_processus)
2408: .pointeur_variable_courante).objet =
2409: NULL;
2410:
2411: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2412: .pointeur_variable_partagee_courante)
2413: .mutex)) != 0)
2414: {
2415: (*s_etat_processus).erreur_systeme =
2416: d_es_processus;
2417: }
2418: }
2419:
2420: if (presence_egalite == d_vrai)
2421: {
2422: liberation(s_etat_processus, s_objet_evalue);
2423: }
2424:
2425: (*s_etat_processus).erreur_execution =
2426: d_ex_erreur_type_argument;
2427: (*s_etat_processus).instruction_courante =
2428: instruction_courante;
2429: (*s_etat_processus).mode_execution_programme =
2430: registre_mode_execution_programme;
2431: return(d_erreur);
2432: }
2433:
2434: i = (*((integer8 *) (*s_objet_indice_i).objet));
2435:
2436: liberation(s_etat_processus, s_objet_indice_i);
2437:
2438: if ((i < 1) || (i > (integer8) (*((struct_vecteur *)
2439: (*((*(*s_etat_processus)
2440: .pointeur_variable_courante).objet)).objet))
2441: .taille))
2442: {
2443: free(s_objet_elementaire);
2444:
2445: if (presence_variable_partagee == d_vrai)
2446: {
2447: (*(*s_etat_processus)
2448: .pointeur_variable_courante).objet =
2449: NULL;
2450:
2451: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2452: .pointeur_variable_partagee_courante)
2453: .mutex)) != 0)
2454: {
2455: (*s_etat_processus).erreur_systeme =
2456: d_es_processus;
2457: }
2458: }
2459:
2460: if (presence_egalite == d_vrai)
2461: {
2462: liberation(s_etat_processus, s_objet_evalue);
2463: }
2464:
2465: (*s_etat_processus).erreur_execution =
2466: d_ex_element_inexistant;
2467: (*s_etat_processus).instruction_courante =
2468: instruction_courante;
2469: (*s_etat_processus).mode_execution_programme =
2470: registre_mode_execution_programme;
2471: return(d_erreur);
2472: }
2473:
2474: if ((*((*(*s_etat_processus)
2475: .pointeur_variable_courante).objet)).type
2476: == VIN)
2477: {
2478: if (((*s_objet_elementaire).objet = malloc(sizeof(
2479: integer8))) == NULL)
2480: {
2481: if (presence_egalite == d_vrai)
2482: {
2483: liberation(s_etat_processus,
2484: s_objet_evalue);
2485: }
2486:
2487: if (presence_variable_partagee == d_vrai)
2488: {
2489: (*(*s_etat_processus)
2490: .pointeur_variable_courante).objet =
2491: NULL;
2492:
2493: if (pthread_mutex_unlock(
2494: &((*(*s_etat_processus)
2495: .pointeur_variable_partagee_courante
2496: ).mutex)) != 0)
2497: {
2498: (*s_etat_processus).erreur_systeme =
2499: d_es_processus;
2500: }
2501: }
2502:
2503: (*s_etat_processus).erreur_systeme =
2504: d_es_allocation_memoire;
2505: (*s_etat_processus).instruction_courante =
2506: instruction_courante;
2507: return(d_erreur);
2508: }
2509:
2510: (*s_objet_elementaire).type = INT;
2511: (*((integer8 *) (*s_objet_elementaire).objet)) =
2512: ((integer8 *) (*((struct_vecteur *)
2513: (*((*(*s_etat_processus)
2514: .pointeur_variable_courante).objet))
2515: .objet)).tableau)[i - 1];
2516: }
2517: else if ((*((*(*s_etat_processus)
2518: .pointeur_variable_courante).objet)).type
2519: == VRL)
2520: {
2521: if (((*s_objet_elementaire).objet = malloc(sizeof(
2522: real8))) == NULL)
2523: {
2524: if (presence_variable_partagee == d_vrai)
2525: {
2526: (*(*s_etat_processus)
2527: .pointeur_variable_courante).objet =
2528: NULL;
2529:
2530: if (pthread_mutex_unlock(
2531: &((*(*s_etat_processus)
2532: .pointeur_variable_partagee_courante
2533: ).mutex)) != 0)
2534: {
2535: (*s_etat_processus).erreur_systeme =
2536: d_es_processus;
2537: }
2538: }
2539:
2540: if (presence_egalite == d_vrai)
2541: {
2542: liberation(s_etat_processus,
2543: s_objet_evalue);
2544: }
2545:
2546: (*s_etat_processus).erreur_systeme =
2547: d_es_allocation_memoire;
2548: (*s_etat_processus).instruction_courante =
2549: instruction_courante;
2550: return(d_erreur);
2551: }
2552:
2553: (*s_objet_elementaire).type = REL;
2554: (*((real8 *) (*s_objet_elementaire).objet)) =
2555: ((real8 *) (*((struct_vecteur *)
2556: (*((*(*s_etat_processus)
2557: .pointeur_variable_courante).objet))
2558: .objet)).tableau)[i - 1];
2559: }
2560: else if ((*((*(*s_etat_processus)
2561: .pointeur_variable_courante).objet)).type
2562: == VCX)
2563: {
2564: if (((*s_objet_elementaire).objet = malloc(sizeof(
2565: struct_complexe16))) == NULL)
2566: {
2567: if (presence_variable_partagee == d_vrai)
2568: {
2569: (*(*s_etat_processus)
2570: .pointeur_variable_courante).objet =
2571: NULL;
2572:
2573: if (pthread_mutex_unlock(
2574: &((*(*s_etat_processus)
2575: .pointeur_variable_partagee_courante
2576: ).mutex)) != 0)
2577: {
2578: (*s_etat_processus).erreur_systeme =
2579: d_es_processus;
2580: }
2581: }
2582:
2583: if (presence_egalite == d_vrai)
2584: {
2585: liberation(s_etat_processus,
2586: s_objet_evalue);
2587: }
2588:
2589: (*s_etat_processus).erreur_systeme =
2590: d_es_allocation_memoire;
2591: (*s_etat_processus).instruction_courante =
2592: instruction_courante;
2593: return(d_erreur);
2594: }
2595:
2596: (*s_objet_elementaire).type = CPL;
2597: (*((struct_complexe16 *) (*s_objet_elementaire)
2598: .objet)).partie_reelle =
2599: ((struct_complexe16 *) (*((struct_vecteur *)
2600: (*((*(*s_etat_processus)
2601: .pointeur_variable_courante).objet))
2602: .objet)).tableau)[i - 1].partie_reelle;
2603: (*((struct_complexe16 *) (*s_objet_elementaire)
2604: .objet)).partie_imaginaire =
2605: ((struct_complexe16 *) (*((struct_vecteur *)
2606: (*((*(*s_etat_processus)
2607: .pointeur_variable_courante).objet))
2608: .objet)).tableau)[i - 1].partie_imaginaire;
2609: }
2610: }
2611:
2612: /*
2613: * Recherche d'un élément dans une matrice
2614: */
2615:
2616: else if ((((*((*(*s_etat_processus)
2617: .pointeur_variable_courante).objet)).type == MIN) ||
2618: ((*((*(*s_etat_processus)
2619: .pointeur_variable_courante).objet)).type == MRL) ||
2620: ((*((*(*s_etat_processus)
2621: .pointeur_variable_courante).objet)).type == MCX))
2622: && ((*((struct_fonction *) (*(*l_element_courant)
2623: .donnee).objet)).nombre_arguments == 2))
2624: {
2625: if (depilement(s_etat_processus, &((*s_etat_processus)
2626: .l_base_pile), &s_objet_indice_j) == d_erreur)
2627: {
2628: free(s_objet_elementaire);
2629:
2630: if (presence_variable_partagee == d_vrai)
2631: {
2632: (*(*s_etat_processus)
2633: .pointeur_variable_courante).objet =
2634: NULL;
2635:
2636: if (pthread_mutex_unlock(
2637: &((*(*s_etat_processus)
2638: .pointeur_variable_partagee_courante)
2639: .mutex)) != 0)
2640: {
2641: (*s_etat_processus).erreur_systeme =
2642: d_es_processus;
2643: }
2644: }
2645:
2646: if (presence_egalite == d_vrai)
2647: {
2648: liberation(s_etat_processus, s_objet_evalue);
2649: }
2650:
2651: (*s_etat_processus).erreur_execution =
2652: d_ex_manque_argument;
2653: (*s_etat_processus).instruction_courante =
2654: instruction_courante;
2655: (*s_etat_processus).mode_execution_programme =
2656: registre_mode_execution_programme;
2657: return(d_erreur);
2658: }
2659:
2660: if (depilement(s_etat_processus, &((*s_etat_processus)
2661: .l_base_pile), &s_objet_indice_i) == d_erreur)
2662: {
2663: liberation(s_etat_processus, s_objet_indice_j);
2664: free(s_objet_elementaire);
2665:
2666: if (presence_variable_partagee == d_vrai)
2667: {
2668: (*(*s_etat_processus)
2669: .pointeur_variable_courante).objet =
2670: NULL;
2671:
2672: if (pthread_mutex_unlock(
2673: &((*(*s_etat_processus)
2674: .pointeur_variable_partagee_courante)
2675: .mutex)) != 0)
2676: {
2677: (*s_etat_processus).erreur_systeme =
2678: d_es_processus;
2679: }
2680: }
2681:
2682: if (presence_egalite == d_vrai)
2683: {
2684: liberation(s_etat_processus, s_objet_evalue);
2685: }
2686:
2687: (*s_etat_processus).erreur_execution =
2688: d_ex_manque_argument;
2689: (*s_etat_processus).instruction_courante =
2690: instruction_courante;
2691: (*s_etat_processus).mode_execution_programme =
2692: registre_mode_execution_programme;
2693: return(d_erreur);
2694: }
2695:
2696: if (((*s_objet_indice_i).type != INT) ||
2697: ((*s_objet_indice_j).type != INT))
2698: {
2699: liberation(s_etat_processus, s_objet_indice_i);
2700: liberation(s_etat_processus, s_objet_indice_j);
2701: free(s_objet_elementaire);
2702:
2703: if (presence_variable_partagee == d_vrai)
2704: {
2705: (*(*s_etat_processus)
2706: .pointeur_variable_courante).objet =
2707: NULL;
2708:
2709: if (pthread_mutex_unlock(
2710: &((*(*s_etat_processus)
2711: .pointeur_variable_partagee_courante)
2712: .mutex)) != 0)
2713: {
2714: (*s_etat_processus).erreur_systeme =
2715: d_es_processus;
2716: }
2717: }
2718:
2719: if (presence_egalite == d_vrai)
2720: {
2721: liberation(s_etat_processus, s_objet_evalue);
2722: }
2723:
2724: (*s_etat_processus).erreur_execution =
2725: d_ex_erreur_type_argument;
2726: (*s_etat_processus).instruction_courante =
2727: instruction_courante;
2728: (*s_etat_processus).mode_execution_programme =
2729: registre_mode_execution_programme;
2730: return(d_erreur);
2731: }
2732:
2733: i = (*((integer8 *) (*s_objet_indice_i).objet));
2734: j = (*((integer8 *) (*s_objet_indice_j).objet));
2735:
2736: liberation(s_etat_processus, s_objet_indice_i);
2737: liberation(s_etat_processus, s_objet_indice_j);
2738:
2739: if ((i < 1) || (i > (integer8) (*((struct_matrice *)
2740: (*((*(*s_etat_processus)
2741: .pointeur_variable_courante).objet)).objet))
2742: .nombre_lignes) || (j < 1) || (j > (integer8)
2743: (*((struct_matrice *) (*((*(*s_etat_processus)
2744: .pointeur_variable_courante).objet)).objet))
2745: .nombre_colonnes))
2746: {
2747: free(s_objet_elementaire);
2748:
2749: if (presence_variable_partagee == d_vrai)
2750: {
2751: (*(*s_etat_processus)
2752: .pointeur_variable_courante).objet =
2753: NULL;
2754:
2755: if (pthread_mutex_unlock(
2756: &((*(*s_etat_processus)
2757: .pointeur_variable_partagee_courante)
2758: .mutex)) != 0)
2759: {
2760: (*s_etat_processus).erreur_systeme =
2761: d_es_processus;
2762: }
2763: }
2764:
2765: if (presence_egalite == d_vrai)
2766: {
2767: liberation(s_etat_processus, s_objet_evalue);
2768: }
2769:
2770: (*s_etat_processus).erreur_execution =
2771: d_ex_element_inexistant;
2772: (*s_etat_processus).instruction_courante =
2773: instruction_courante;
2774: (*s_etat_processus).mode_execution_programme =
2775: registre_mode_execution_programme;
2776: return(d_erreur);
2777: }
2778:
2779: if ((*((*(*s_etat_processus).pointeur_variable_courante)
2780: .objet)).type == MIN)
2781: {
2782: if (((*s_objet_elementaire).objet = malloc(sizeof(
2783: integer8))) == NULL)
2784: {
2785: if (presence_variable_partagee == d_vrai)
2786: {
2787: (*(*s_etat_processus)
2788: .pointeur_variable_courante).objet =
2789: NULL;
2790:
2791: if (pthread_mutex_unlock(
2792: &((*(*s_etat_processus)
2793: .pointeur_variable_partagee_courante
2794: ).mutex)) != 0)
2795: {
2796: (*s_etat_processus).erreur_systeme =
2797: d_es_processus;
2798: }
2799: }
2800:
2801: if (presence_egalite == d_vrai)
2802: {
2803: liberation(s_etat_processus,
2804: s_objet_evalue);
2805: }
2806:
2807: (*s_etat_processus).erreur_systeme =
2808: d_es_allocation_memoire;
2809: (*s_etat_processus).instruction_courante =
2810: instruction_courante;
2811: return(d_erreur);
2812: }
2813:
2814: (*s_objet_elementaire).type = INT;
2815: (*((integer8 *) (*s_objet_elementaire).objet)) =
2816: ((integer8 **) (*((struct_matrice *)
2817: (*((*(*s_etat_processus)
2818: .pointeur_variable_courante).objet))
2819: .objet)).tableau)[i - 1][j - 1];
2820: }
2821: else if ((*((*(*s_etat_processus)
2822: .pointeur_variable_courante).objet)).type
2823: == MRL)
2824: {
2825: if (((*s_objet_elementaire).objet = malloc(sizeof(
2826: real8))) == NULL)
2827: {
2828: if (presence_variable_partagee == d_vrai)
2829: {
2830: (*(*s_etat_processus)
2831: .pointeur_variable_courante).objet =
2832: NULL;
2833:
2834: if (pthread_mutex_unlock(
2835: &((*(*s_etat_processus)
2836: .pointeur_variable_partagee_courante
2837: ).mutex)) != 0)
2838: {
2839: (*s_etat_processus).erreur_systeme =
2840: d_es_processus;
2841: }
2842: }
2843:
2844: if (presence_egalite == d_vrai)
2845: {
2846: liberation(s_etat_processus,
2847: s_objet_evalue);
2848: }
2849:
2850: (*s_etat_processus).erreur_systeme =
2851: d_es_allocation_memoire;
2852: (*s_etat_processus).instruction_courante =
2853: instruction_courante;
2854: return(d_erreur);
2855: }
2856:
2857: (*s_objet_elementaire).type = REL;
2858: (*((real8 *) (*s_objet_elementaire).objet)) =
2859: ((real8 **) (*((struct_matrice *)
2860: (*((*(*s_etat_processus)
2861: .pointeur_variable_courante).objet))
2862: .objet)).tableau)[i - 1][j - 1];
2863: }
2864: else if ((*((*(*s_etat_processus)
2865: .pointeur_variable_courante).objet)).type
2866: == MCX)
2867: {
2868: if (((*s_objet_elementaire).objet = malloc(sizeof(
2869: struct_complexe16))) == NULL)
2870: {
2871: if (presence_variable_partagee == d_vrai)
2872: {
2873: (*(*s_etat_processus)
2874: .pointeur_variable_courante).objet =
2875: NULL;
2876:
2877: if (pthread_mutex_unlock(
2878: &((*(*s_etat_processus)
2879: .pointeur_variable_partagee_courante
2880: ).mutex)) != 0)
2881: {
2882: (*s_etat_processus).erreur_systeme =
2883: d_es_processus;
2884: }
2885: }
2886:
2887: if (presence_egalite == d_vrai)
2888: {
2889: liberation(s_etat_processus,
2890: s_objet_evalue);
2891: }
2892:
2893: (*s_etat_processus).erreur_systeme =
2894: d_es_allocation_memoire;
2895: (*s_etat_processus).instruction_courante =
2896: instruction_courante;
2897: return(d_erreur);
2898: }
2899:
2900: (*s_objet_elementaire).type = CPL;
2901: (*((struct_complexe16 *) (*s_objet_elementaire)
2902: .objet)).partie_reelle =
2903: ((struct_complexe16 **)
2904: (*((struct_matrice *)
2905: (*((*(*s_etat_processus)
2906: .pointeur_variable_courante).objet))
2907: .objet)).tableau)[i - 1][j - 1]
2908: .partie_reelle;
2909: (*((struct_complexe16 *) (*s_objet_elementaire)
2910: .objet)).partie_imaginaire =
2911: ((struct_complexe16 **)
2912: (*((struct_matrice *)
2913: (*((*(*s_etat_processus)
2914: .pointeur_variable_courante).objet))
2915: .objet)).tableau)[i - 1][j - 1]
2916: .partie_imaginaire;
2917: }
2918: }
2919:
2920: /*
2921: * Recherche de l'élément idoine dans la liste
2922: */
2923:
2924: else if (((*((*(*s_etat_processus)
2925: .pointeur_variable_courante).objet)).type == LST) &&
2926: ((*((struct_fonction *) (*(*l_element_courant)
2927: .donnee).objet)).nombre_arguments == 1))
2928: {
2929: if (depilement(s_etat_processus, &((*s_etat_processus)
2930: .l_base_pile), &s_objet_indice_i) == d_erreur)
2931: {
2932: free(s_objet_elementaire);
2933:
2934: if (presence_variable_partagee == d_vrai)
2935: {
2936: (*(*s_etat_processus)
2937: .pointeur_variable_courante).objet =
2938: NULL;
2939:
2940: if (pthread_mutex_unlock(
2941: &((*(*s_etat_processus)
2942: .pointeur_variable_partagee_courante)
2943: .mutex)) != 0)
2944: {
2945: (*s_etat_processus).erreur_systeme =
2946: d_es_processus;
2947: }
2948: }
2949:
2950: if (presence_egalite == d_vrai)
2951: {
2952: liberation(s_etat_processus, s_objet_evalue);
2953: }
2954:
2955: (*s_etat_processus).erreur_execution =
2956: d_ex_manque_argument;
2957: (*s_etat_processus).instruction_courante =
2958: instruction_courante;
2959: (*s_etat_processus).mode_execution_programme =
2960: registre_mode_execution_programme;
2961: return(d_erreur);
2962: }
2963:
2964: if ((*s_objet_indice_i).type != INT)
2965: {
2966: liberation(s_etat_processus, s_objet_indice_i);
2967: free(s_objet_elementaire);
2968:
2969: if (presence_variable_partagee == d_vrai)
2970: {
2971: (*(*s_etat_processus)
2972: .pointeur_variable_courante).objet =
2973: NULL;
2974:
2975: if (pthread_mutex_unlock(
2976: &((*(*s_etat_processus)
2977: .pointeur_variable_partagee_courante)
2978: .mutex)) != 0)
2979: {
2980: (*s_etat_processus).erreur_systeme =
2981: d_es_processus;
2982: }
2983: }
2984:
2985: if (presence_egalite == d_vrai)
2986: {
2987: liberation(s_etat_processus, s_objet_evalue);
2988: }
2989:
2990: (*s_etat_processus).erreur_execution =
2991: d_ex_erreur_type_argument;
2992: (*s_etat_processus).instruction_courante =
2993: instruction_courante;
2994: (*s_etat_processus).mode_execution_programme =
2995: registre_mode_execution_programme;
2996: return(d_erreur);
2997: }
2998:
2999: i = (*((integer8 *) (*s_objet_indice_i).objet));
3000:
3001: liberation(s_etat_processus, s_objet_indice_i);
3002:
3003: l_sous_element_courant = (*((*(*s_etat_processus)
3004: .pointeur_variable_courante).objet)).objet;
3005: j = 0;
3006:
3007: while(l_sous_element_courant != NULL)
3008: {
3009: if ((++j) == i)
3010: {
3011: break;
3012: }
3013:
3014: l_sous_element_courant =
3015: (*l_sous_element_courant).suivant;
3016: }
3017:
3018: if (j != i)
3019: {
3020: free(s_objet_elementaire);
3021:
3022: if (presence_variable_partagee == d_vrai)
3023: {
3024: (*(*s_etat_processus)
3025: .pointeur_variable_courante).objet =
3026: NULL;
3027:
3028: if (pthread_mutex_unlock(
3029: &((*(*s_etat_processus)
3030: .pointeur_variable_partagee_courante)
3031: .mutex)) != 0)
3032: {
3033: (*s_etat_processus).erreur_systeme =
3034: d_es_processus;
3035: }
3036: }
3037:
3038: if (presence_egalite == d_vrai)
3039: {
3040: liberation(s_etat_processus, s_objet_evalue);
3041: }
3042:
3043: (*s_etat_processus).erreur_execution =
3044: d_ex_element_inexistant;
3045: (*s_etat_processus).instruction_courante =
3046: instruction_courante;
3047: (*s_etat_processus).mode_execution_programme =
3048: registre_mode_execution_programme;
3049: return(d_erreur);
3050: }
3051:
3052: free(s_objet_elementaire);
3053:
3054: if ((s_objet_elementaire =
3055: copie_objet(s_etat_processus,
3056: (*l_sous_element_courant).donnee, 'P')) == NULL)
3057: {
3058: if (presence_variable_partagee == d_vrai)
3059: {
3060: (*(*s_etat_processus)
3061: .pointeur_variable_courante).objet =
3062: NULL;
3063:
3064: if (pthread_mutex_unlock(
3065: &((*(*s_etat_processus)
3066: .pointeur_variable_partagee_courante)
3067: .mutex)) != 0)
3068: {
3069: (*s_etat_processus).erreur_systeme =
3070: d_es_processus;
3071: }
3072: }
3073:
3074: if (presence_egalite == d_vrai)
3075: {
3076: liberation(s_etat_processus, s_objet_evalue);
3077: }
3078:
3079: (*s_etat_processus).erreur_systeme =
3080: d_es_allocation_memoire;
3081: (*s_etat_processus).instruction_courante =
3082: instruction_courante;
3083: return(d_erreur);
3084: }
3085:
3086: // Si l'objet élémentaire est un nom et que ce nom n'est
3087: // pas un nom symbolique, il convient de l'évaluer.
3088:
3089: if ((*s_objet_elementaire).type == NOM)
3090: {
3091: if (((*((struct_nom *) (*s_objet_elementaire)
3092: .objet)).symbole == d_faux) ||
3093: (type_evaluation == 'N'))
3094: {
3095: if (evaluation(s_etat_processus,
3096: s_objet_elementaire, 'E') == d_erreur)
3097: {
3098: if (presence_variable_partagee == d_vrai)
3099: {
3100: (*(*s_etat_processus)
3101: .pointeur_variable_courante)
3102: .objet = NULL;
3103:
3104: if (pthread_mutex_unlock(
3105: &((*(*s_etat_processus)
3106: .pointeur_variable_partagee_courante
3107: ).mutex)) != 0)
3108: {
3109: (*s_etat_processus).erreur_systeme =
3110: d_es_processus;
3111: }
3112: }
3113:
3114: if (presence_egalite == d_vrai)
3115: {
3116: liberation(s_etat_processus,
3117: s_objet_evalue);
3118: }
3119:
3120: (*s_etat_processus).erreur_systeme =
3121: d_es_allocation_memoire;
3122: (*s_etat_processus).instruction_courante =
3123: instruction_courante;
3124: return(d_erreur);
3125: }
3126:
3127: liberation(s_etat_processus,
3128: s_objet_elementaire);
3129:
3130:
3131: if (depilement(s_etat_processus,
3132: &((*s_etat_processus).l_base_pile),
3133: &s_objet_elementaire) == d_erreur)
3134: {
3135: if (presence_variable_partagee == d_vrai)
3136: {
3137: (*(*s_etat_processus)
3138: .pointeur_variable_courante)
3139: .objet = NULL;
3140:
3141: if (pthread_mutex_unlock(
3142: &((*(*s_etat_processus)
3143: .pointeur_variable_partagee_courante
3144: ).mutex)) != 0)
3145: {
3146: (*s_etat_processus).erreur_systeme =
3147: d_es_processus;
3148: }
3149: }
3150:
3151: if (presence_egalite == d_vrai)
3152: {
3153: liberation(s_etat_processus,
3154: s_objet_evalue);
3155: }
3156:
3157: (*s_etat_processus).erreur_systeme =
3158: d_es_allocation_memoire;
3159: (*s_etat_processus).instruction_courante =
3160: instruction_courante;
3161: return(d_erreur);
3162: }
3163: }
3164: }
3165: }
3166:
3167: /*
3168: * Recherche de l'élément idoine dans la table
3169: */
3170:
3171: else if (((*((*(*s_etat_processus)
3172: .pointeur_variable_courante).objet)).type == TBL) &&
3173: ((*((struct_fonction *) (*(*l_element_courant)
3174: .donnee).objet)).nombre_arguments == 1))
3175: {
3176: if (depilement(s_etat_processus, &((*s_etat_processus)
3177: .l_base_pile), &s_objet_indice_i) == d_erreur)
3178: {
3179: free(s_objet_elementaire);
3180:
3181: if (presence_variable_partagee == d_vrai)
3182: {
3183: (*(*s_etat_processus)
3184: .pointeur_variable_courante).objet =
3185: NULL;
3186:
3187: if (pthread_mutex_unlock(
3188: &((*(*s_etat_processus)
3189: .pointeur_variable_partagee_courante)
3190: .mutex)) != 0)
3191: {
3192: (*s_etat_processus).erreur_systeme =
3193: d_es_processus;
3194: }
3195: }
3196:
3197: if (presence_egalite == d_vrai)
3198: {
3199: liberation(s_etat_processus, s_objet_evalue);
3200: }
3201:
3202: (*s_etat_processus).erreur_execution =
3203: d_ex_manque_argument;
3204: (*s_etat_processus).instruction_courante =
3205: instruction_courante;
3206: (*s_etat_processus).mode_execution_programme =
3207: registre_mode_execution_programme;
3208: return(d_erreur);
3209: }
3210:
3211: if ((*s_objet_indice_i).type != INT)
3212: {
3213: liberation(s_etat_processus, s_objet_indice_i);
3214: free(s_objet_elementaire);
3215:
3216: if (presence_variable_partagee == d_vrai)
3217: {
3218: (*(*s_etat_processus)
3219: .pointeur_variable_courante).objet =
3220: NULL;
3221:
3222: if (pthread_mutex_unlock(
3223: &((*(*s_etat_processus)
3224: .pointeur_variable_partagee_courante)
3225: .mutex)) != 0)
3226: {
3227: (*s_etat_processus).erreur_systeme =
3228: d_es_processus;
3229: }
3230: }
3231:
3232: if (presence_egalite == d_vrai)
3233: {
3234: liberation(s_etat_processus, s_objet_evalue);
3235: }
3236:
3237: (*s_etat_processus).erreur_execution =
3238: d_ex_erreur_type_argument;
3239: (*s_etat_processus).instruction_courante =
3240: instruction_courante;
3241: (*s_etat_processus).mode_execution_programme =
3242: registre_mode_execution_programme;
3243: return(d_erreur);
3244: }
3245:
3246: i = (*((integer8 *) (*s_objet_indice_i).objet));
3247:
3248: liberation(s_etat_processus, s_objet_indice_i);
3249:
3250: if ((i < 1) || (i > (integer8) (*((struct_tableau *)
3251: (*(*(*s_etat_processus)
3252: .pointeur_variable_courante).objet)
3253: .objet)).nombre_elements))
3254: {
3255: free(s_objet_elementaire);
3256:
3257: if (presence_variable_partagee == d_vrai)
3258: {
3259: (*(*s_etat_processus)
3260: .pointeur_variable_courante).objet =
3261: NULL;
3262:
3263: if (pthread_mutex_unlock(
3264: &((*(*s_etat_processus)
3265: .pointeur_variable_partagee_courante)
3266: .mutex)) != 0)
3267: {
3268: (*s_etat_processus).erreur_systeme =
3269: d_es_processus;
3270: }
3271: }
3272:
3273: if (presence_egalite == d_vrai)
3274: {
3275: liberation(s_etat_processus, s_objet_evalue);
3276: }
3277:
3278: (*s_etat_processus).erreur_execution =
3279: d_ex_element_inexistant;
3280: (*s_etat_processus).instruction_courante =
3281: instruction_courante;
3282: (*s_etat_processus).mode_execution_programme =
3283: registre_mode_execution_programme;
3284: return(d_erreur);
3285: }
3286:
3287: free(s_objet_elementaire);
3288:
3289: if ((s_objet_elementaire =
3290: copie_objet(s_etat_processus,
3291: (*((struct_tableau *) (*(*(*s_etat_processus)
3292: .pointeur_variable_courante).objet)
3293: .objet)).elements[i - 1], 'P')) == NULL)
3294: {
3295: if (presence_variable_partagee == d_vrai)
3296: {
3297: (*(*s_etat_processus)
3298: .pointeur_variable_courante).objet =
3299: NULL;
3300:
3301: if (pthread_mutex_unlock(
3302: &((*(*s_etat_processus)
3303: .pointeur_variable_partagee_courante)
3304: .mutex)) != 0)
3305: {
3306: (*s_etat_processus).erreur_systeme =
3307: d_es_processus;
3308: }
3309: }
3310:
3311: if (presence_egalite == d_vrai)
3312: {
3313: liberation(s_etat_processus, s_objet_evalue);
3314: }
3315:
3316: (*s_etat_processus).erreur_systeme =
3317: d_es_allocation_memoire;
3318: (*s_etat_processus).instruction_courante =
3319: instruction_courante;
3320: return(d_erreur);
3321: }
3322:
3323: // Si l'objet élémentaire est un nom et que ce nom n'est
3324: // pas un nom symbolique, il convient de l'évaluer.
3325:
3326: if ((*s_objet_elementaire).type == NOM)
3327: {
3328: if (((*((struct_nom *) (*s_objet_elementaire)
3329: .objet)).symbole == d_faux) ||
3330: (type_evaluation == 'N'))
3331: {
3332: if (evaluation(s_etat_processus,
3333: s_objet_elementaire, 'E') == d_erreur)
3334: {
3335: if (presence_variable_partagee == d_vrai)
3336: {
3337: (*(*s_etat_processus)
3338: .pointeur_variable_courante)
3339: .objet = NULL;
3340:
3341: if (pthread_mutex_unlock(
3342: &((*(*s_etat_processus)
3343: .pointeur_variable_partagee_courante
3344: ).mutex)) != 0)
3345: {
3346: (*s_etat_processus).erreur_systeme =
3347: d_es_processus;
3348: }
3349: }
3350:
3351: if (presence_egalite == d_vrai)
3352: {
3353: liberation(s_etat_processus,
3354: s_objet_evalue);
3355: }
3356:
3357: (*s_etat_processus).erreur_systeme =
3358: d_es_allocation_memoire;
3359: (*s_etat_processus).instruction_courante =
3360: instruction_courante;
3361: return(d_erreur);
3362: }
3363:
3364: liberation(s_etat_processus,
3365: s_objet_elementaire);
3366:
3367:
3368: if (depilement(s_etat_processus,
3369: &((*s_etat_processus).l_base_pile),
3370: &s_objet_elementaire) == d_erreur)
3371: {
3372: if (presence_variable_partagee == d_vrai)
3373: {
3374: (*(*s_etat_processus)
3375: .pointeur_variable_courante)
3376: .objet = NULL;
3377:
3378: if (pthread_mutex_unlock(
3379: &((*(*s_etat_processus)
3380: .pointeur_variable_partagee_courante
3381: ).mutex)) != 0)
3382: {
3383: (*s_etat_processus).erreur_systeme =
3384: d_es_processus;
3385: }
3386: }
3387:
3388: if (presence_egalite == d_vrai)
3389: {
3390: liberation(s_etat_processus,
3391: s_objet_evalue);
3392: }
3393:
3394: (*s_etat_processus).erreur_systeme =
3395: d_es_allocation_memoire;
3396: (*s_etat_processus).instruction_courante =
3397: instruction_courante;
3398: return(d_erreur);
3399: }
3400: }
3401: }
3402: }
3403: else if (((*((*(*s_etat_processus)
3404: .pointeur_variable_courante).objet)).type == ALG) ||
3405: ((*((*(*s_etat_processus)
3406: .pointeur_variable_courante).objet)).type == RPN))
3407: {
3408: registre_evaluation_expression_compilee =
3409: (*s_etat_processus)
3410: .evaluation_expression_compilee;
3411:
3412: if (((*(*s_etat_processus).pointeur_variable_courante)
3413: .origine == 'E') && ((*(*s_etat_processus)
3414: .pointeur_variable_courante).niveau == 0))
3415: {
3416: (*s_etat_processus).evaluation_expression_compilee =
3417: 'Y';
3418: }
3419: else
3420: {
3421: (*s_etat_processus).evaluation_expression_compilee =
3422: 'N';
3423: }
3424:
3425: if (evaluation(s_etat_processus, (*(*s_etat_processus)
3426: .pointeur_variable_courante).objet,
3427: type_evaluation) == d_erreur)
3428: {
3429: (*s_etat_processus).evaluation_expression_compilee =
3430: registre_evaluation_expression_compilee;
3431:
3432: if (presence_variable_partagee == d_vrai)
3433: {
3434: (*(*s_etat_processus)
3435: .pointeur_variable_courante).objet =
3436: NULL;
3437:
3438: if (pthread_mutex_unlock(
3439: &((*(*s_etat_processus)
3440: .pointeur_variable_partagee_courante)
3441: .mutex)) != 0)
3442: {
3443: (*s_etat_processus).erreur_systeme =
3444: d_es_processus;
3445: }
3446: }
3447:
3448: if (presence_egalite == d_vrai)
3449: {
3450: liberation(s_etat_processus, s_objet_evalue);
3451: }
3452:
3453: (*s_etat_processus).instruction_courante =
3454: instruction_courante;
3455: (*s_etat_processus).mode_execution_programme =
3456: registre_mode_execution_programme;
3457: return(d_erreur);
3458: }
3459:
3460: (*s_etat_processus).evaluation_expression_compilee =
3461: registre_evaluation_expression_compilee;
3462:
3463: free(s_objet_elementaire);
3464:
3465: if (depilement(s_etat_processus, &((*s_etat_processus)
3466: .l_base_pile), &s_objet_elementaire)
3467: == d_erreur)
3468: {
3469: if (presence_variable_partagee == d_vrai)
3470: {
3471: (*(*s_etat_processus)
3472: .pointeur_variable_courante).objet =
3473: NULL;
3474:
3475: if (pthread_mutex_unlock(
3476: &((*(*s_etat_processus)
3477: .pointeur_variable_partagee_courante)
3478: .mutex)) != 0)
3479: {
3480: (*s_etat_processus).erreur_systeme =
3481: d_es_processus;
3482: }
3483: }
3484:
3485: if (presence_egalite == d_vrai)
3486: {
3487: liberation(s_etat_processus, s_objet_evalue);
3488: }
3489:
3490: (*s_etat_processus).erreur_execution =
3491: d_ex_manque_argument;
3492: (*s_etat_processus).instruction_courante =
3493: instruction_courante;
3494: (*s_etat_processus).mode_execution_programme =
3495: registre_mode_execution_programme;
3496: return(d_erreur);
3497: }
3498: }
3499: else if ((*((*(*s_etat_processus)
3500: .pointeur_variable_courante).objet)).type == ADR)
3501: {
3502: autorisation_empilement_programme = (*s_etat_processus)
3503: .autorisation_empilement_programme;
3504: registre_position_courante = (*s_etat_processus)
3505: .position_courante;
3506:
3507: empilement_pile_systeme(s_etat_processus);
3508:
3509: if ((*s_etat_processus).erreur_systeme != d_es)
3510: {
3511: if (presence_variable_partagee == d_vrai)
3512: {
3513: (*(*s_etat_processus)
3514: .pointeur_variable_courante).objet =
3515: NULL;
3516:
3517: if (pthread_mutex_unlock(
3518: &((*(*s_etat_processus)
3519: .pointeur_variable_partagee_courante)
3520: .mutex)) != 0)
3521: {
3522: (*s_etat_processus).erreur_systeme =
3523: d_es_processus;
3524: }
3525: }
3526:
3527: if (presence_egalite == d_vrai)
3528: {
3529: liberation(s_etat_processus, s_objet_evalue);
3530: }
3531:
3532: depilement_pile_systeme(s_etat_processus);
3533:
3534: (*s_etat_processus).instruction_courante =
3535: instruction_courante;
3536: return(d_erreur);
3537: }
3538:
3539: (*(*s_etat_processus).l_base_pile_systeme)
3540: .retour_definition = 'Y';
3541: (*(*s_etat_processus).l_base_pile_systeme)
3542: .origine_routine_evaluation = 'Y';
3543:
3544: (*s_etat_processus).mode_execution_programme = 'Y';
3545: (*s_etat_processus).autorisation_empilement_programme
3546: = 'N';
3547:
3548: (*(*s_etat_processus).l_base_pile_systeme)
3549: .niveau_courant = (*s_etat_processus)
3550: .niveau_courant;
3551:
3552: (*s_etat_processus).position_courante =
3553: (*((integer8 *) ((*(*(*s_etat_processus)
3554: .pointeur_variable_courante).objet).objet)));
3555:
3556: if ((*s_etat_processus).profilage == d_vrai)
3557: {
3558: profilage(s_etat_processus,
3559: (*(*s_etat_processus)
3560: .pointeur_variable_courante).nom);
3561:
3562: if ((*s_etat_processus).erreur_systeme != d_es)
3563: {
3564: if (presence_variable_partagee == d_vrai)
3565: {
3566: (*(*s_etat_processus)
3567: .pointeur_variable_courante).objet =
3568: NULL;
3569:
3570: if (pthread_mutex_unlock(
3571: &((*(*s_etat_processus)
3572: .pointeur_variable_partagee_courante
3573: ).mutex)) != 0)
3574: {
3575: (*s_etat_processus).erreur_systeme =
3576: d_es_processus;
3577: }
3578: }
3579:
3580: return(d_erreur);
3581: }
3582: }
3583:
3584: registre_evaluation_forcee =
3585: (*s_etat_processus).evaluation_forcee;
3586:
3587: if (type_evaluation == 'N')
3588: {
3589: (*s_etat_processus).evaluation_forcee = 'Y';
3590: }
3591:
3592: if (sequenceur(s_etat_processus) == d_erreur)
3593: {
3594: (*s_etat_processus).evaluation_forcee =
3595: registre_evaluation_forcee;
3596:
3597: if (presence_variable_partagee == d_vrai)
3598: {
3599: (*(*s_etat_processus)
3600: .pointeur_variable_courante).objet =
3601: NULL;
3602:
3603: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3604: .pointeur_variable_partagee_courante)
3605: .mutex)) != 0)
3606: {
3607: (*s_etat_processus).erreur_systeme =
3608: d_es_processus;
3609: }
3610: }
3611:
3612: if (presence_egalite == d_vrai)
3613: {
3614: liberation(s_etat_processus, s_objet_evalue);
3615: }
3616:
3617: depilement_pile_systeme(s_etat_processus);
3618:
3619: (*s_etat_processus).instruction_courante =
3620: instruction_courante;
3621: (*s_etat_processus).mode_execution_programme =
3622: registre_mode_execution_programme;
3623: return(d_erreur);
3624: }
3625:
3626: (*s_etat_processus).evaluation_forcee =
3627: registre_evaluation_forcee;
3628: (*s_etat_processus).instruction_courante =
3629: instruction_courante;
3630: (*s_etat_processus).mode_execution_programme = 'N';
3631:
3632: depilement_pile_systeme(s_etat_processus);
3633:
3634: if ((*s_etat_processus).erreur_systeme != d_es)
3635: {
3636: if (presence_variable_partagee == d_vrai)
3637: {
3638: (*(*s_etat_processus)
3639: .pointeur_variable_courante).objet =
3640: NULL;
3641:
3642: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3643: .pointeur_variable_partagee_courante)
3644: .mutex)) != 0)
3645: {
3646: (*s_etat_processus).erreur_systeme =
3647: d_es_processus;
3648: }
3649: }
3650:
3651: if (presence_egalite == d_vrai)
3652: {
3653: liberation(s_etat_processus, s_objet_evalue);
3654: }
3655:
3656: return(d_erreur);
3657: }
3658:
3659: (*s_etat_processus).retour_routine_evaluation = 'N';
3660: (*s_etat_processus).position_courante =
3661: registre_position_courante;
3662: (*s_etat_processus).autorisation_empilement_programme =
3663: autorisation_empilement_programme;
3664:
3665: free(s_objet_elementaire);
3666:
3667: if (depilement(s_etat_processus, &((*s_etat_processus)
3668: .l_base_pile), &s_objet_elementaire)
3669: == d_erreur)
3670: {
3671: if (presence_variable_partagee == d_vrai)
3672: {
3673: (*(*s_etat_processus)
3674: .pointeur_variable_courante).objet =
3675: NULL;
3676:
3677: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3678: .pointeur_variable_partagee_courante)
3679: .mutex)) != 0)
3680: {
3681: (*s_etat_processus).erreur_systeme =
3682: d_es_processus;
3683: }
3684: }
3685:
3686: if (presence_egalite == d_vrai)
3687: {
3688: liberation(s_etat_processus, s_objet_evalue);
3689: }
3690:
3691: (*s_etat_processus).erreur_execution =
3692: d_ex_manque_argument;
3693: (*s_etat_processus).instruction_courante =
3694: instruction_courante;
3695: (*s_etat_processus).mode_execution_programme =
3696: registre_mode_execution_programme;
3697: return(d_erreur);
3698: }
3699: }
3700: else
3701: {
3702: if (presence_variable_partagee == d_vrai)
3703: {
3704: (*(*s_etat_processus)
3705: .pointeur_variable_courante).objet =
3706: NULL;
3707:
3708: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3709: .pointeur_variable_partagee_courante)
3710: .mutex)) != 0)
3711: {
3712: (*s_etat_processus).erreur_systeme =
3713: d_es_processus;
3714: }
3715: }
3716:
3717: if (presence_egalite == d_vrai)
3718: {
3719: liberation(s_etat_processus, s_objet_evalue);
3720: }
3721:
3722: (*s_etat_processus).erreur_execution =
3723: d_ex_element_inexistant;
3724: (*s_etat_processus).instruction_courante =
3725: instruction_courante;
3726: (*s_etat_processus).mode_execution_programme =
3727: registre_mode_execution_programme;
3728:
3729: return(d_erreur);
3730: }
3731:
3732: if (empilement(s_etat_processus, &((*s_etat_processus)
3733: .l_base_pile), s_objet_elementaire) == d_erreur)
3734: {
3735: if (presence_variable_partagee == d_vrai)
3736: {
3737: (*(*s_etat_processus)
3738: .pointeur_variable_courante).objet =
3739: NULL;
3740:
3741: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3742: .pointeur_variable_partagee_courante)
3743: .mutex)) != 0)
3744: {
3745: (*s_etat_processus).erreur_systeme =
3746: d_es_processus;
3747: }
3748: }
3749:
3750: if (presence_egalite == d_vrai)
3751: {
3752: liberation(s_etat_processus, s_objet_evalue);
3753: }
3754:
3755: (*s_etat_processus).instruction_courante =
3756: instruction_courante;
3757: return(d_erreur);
3758: }
3759:
3760: if (presence_variable_partagee == d_vrai)
3761: {
3762: (*(*s_etat_processus)
3763: .pointeur_variable_courante).objet = NULL;
3764:
3765: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3766: .pointeur_variable_partagee_courante).mutex))
3767: != 0)
3768: {
3769: (*s_etat_processus).erreur_systeme =
3770: d_es_processus;
3771: }
3772: }
3773: }
3774: }
3775: else if (((*(*l_element_courant).donnee).type == ALG)
3776: || ((*(*l_element_courant).donnee).type == RPN))
3777: {
3778: if (type_evaluation == 'I')
3779: {
3780: if ((s_objet_elementaire = copie_objet(s_etat_processus,
3781: (*l_element_courant).donnee, 'P')) == NULL)
3782: {
3783: if (presence_egalite == d_vrai)
3784: {
3785: liberation(s_etat_processus, s_objet_evalue);
3786: }
3787:
3788: (*s_etat_processus).erreur_systeme =
3789: d_es_allocation_memoire;
3790: (*s_etat_processus).instruction_courante =
3791: instruction_courante;
3792: return(d_erreur);
3793: }
3794:
3795: if (empilement(s_etat_processus, &((*s_etat_processus)
3796: .l_base_pile), s_objet_elementaire)
3797: == d_erreur)
3798: {
3799: if (presence_egalite == d_vrai)
3800: {
3801: liberation(s_etat_processus, s_objet_evalue);
3802: }
3803:
3804: (*s_etat_processus).instruction_courante =
3805: instruction_courante;
3806: return(d_erreur);
3807: }
3808: }
3809: else
3810: {
3811: if ((*s_etat_processus).autorisation_empilement_programme
3812: == 'N')
3813: {
3814: registre_evaluation_expression_compilee =
3815: (*s_etat_processus)
3816: .evaluation_expression_compilee;
3817:
3818: (*s_etat_processus).evaluation_expression_compilee
3819: = 'Y';
3820:
3821: if (evaluation(s_etat_processus, (*l_element_courant)
3822: .donnee, type_evaluation) == d_erreur)
3823: {
3824: (*s_etat_processus).evaluation_expression_compilee
3825: = registre_evaluation_expression_compilee;
3826:
3827: if (presence_egalite == d_vrai)
3828: {
3829: liberation(s_etat_processus, s_objet_evalue);
3830: }
3831:
3832: (*s_etat_processus).instruction_courante =
3833: instruction_courante;
3834: (*s_etat_processus).mode_execution_programme =
3835: registre_mode_execution_programme;
3836: return(d_erreur);
3837: }
3838:
3839: (*s_etat_processus).evaluation_expression_compilee
3840: = registre_evaluation_expression_compilee;
3841: }
3842: else
3843: {
3844: if ((s_objet_elementaire =
3845: copie_objet(s_etat_processus,
3846: (*l_element_courant).donnee, 'P')) == NULL)
3847: {
3848: if (presence_egalite == d_vrai)
3849: {
3850: liberation(s_etat_processus, s_objet_evalue);
3851: }
3852:
3853: (*s_etat_processus).erreur_systeme =
3854: d_es_allocation_memoire;
3855: (*s_etat_processus).instruction_courante =
3856: instruction_courante;
3857: return(d_erreur);
3858: }
3859:
3860: if (empilement(s_etat_processus, &((*s_etat_processus)
3861: .l_base_pile), s_objet_elementaire)
3862: == d_erreur)
3863: {
3864: if (presence_egalite == d_vrai)
3865: {
3866: liberation(s_etat_processus, s_objet_evalue);
3867: }
3868:
3869: (*s_etat_processus).instruction_courante =
3870: instruction_courante;
3871: return(d_erreur);
3872: }
3873: }
3874: }
3875: }
3876: else if ((*(*l_element_courant).donnee).type == NOM)
3877: {
3878: registre_instruction_valide = (*s_etat_processus)
3879: .instruction_valide;
3880: registre_test = (*s_etat_processus).test_instruction;
3881: (*s_etat_processus).test_instruction = 'Y';
3882: (*s_etat_processus).instruction_courante = (*((struct_nom *)
3883: (*(*l_element_courant).donnee).objet)).nom;
3884:
3885: analyse(s_etat_processus, NULL);
3886:
3887: (*s_etat_processus).test_instruction = 'N';
3888:
3889: if ((*s_etat_processus).instruction_valide == 'Y')
3890: {
3891: registre_test_2 = (*s_etat_processus).test_instruction;
3892: (*s_etat_processus).test_instruction = 'N';
3893:
3894: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
3895: == d_vrai) ? 'E' : 'N';
3896:
3897: if (type_evaluation == 'N')
3898: {
3899: cf(s_etat_processus, 35);
3900: }
3901: else
3902: {
3903: sf(s_etat_processus, 35);
3904: }
3905:
3906: analyse(s_etat_processus, NULL);
3907:
3908: if (registre_type_evaluation == 'E')
3909: {
3910: sf(s_etat_processus, 35);
3911: }
3912: else
3913: {
3914: cf(s_etat_processus, 35);
3915: }
3916:
3917: (*s_etat_processus).test_instruction = registre_test_2;
3918:
3919: if ((*s_etat_processus).erreur_systeme != d_es)
3920: {
3921: if (presence_egalite == d_vrai)
3922: {
3923: liberation(s_etat_processus, s_objet_evalue);
3924: }
3925:
3926: if ((*s_etat_processus).var_volatile_processus_pere
3927: == 0)
3928: {
3929: envoi_signal_processus((*s_etat_processus)
3930: .pid_processus_pere, rpl_sigalrm);
3931: }
3932: else
3933: {
3934: (*s_etat_processus).var_volatile_alarme = -1;
3935: }
3936:
3937: (*s_etat_processus).instruction_courante =
3938: instruction_courante;
3939: return(d_erreur);
3940: }
3941: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3942: ((*s_etat_processus).exception != d_ep))
3943: {
3944: if ((*s_etat_processus).arret_si_exception == d_faux)
3945: {
3946: /*
3947: * Reprise sur erreur
3948: */
3949:
3950: if ((message = messages(s_etat_processus)) == NULL)
3951: {
3952: if (presence_egalite == d_vrai)
3953: {
3954: liberation(s_etat_processus,
3955: s_objet_evalue);
3956: }
3957:
3958: (*s_etat_processus).instruction_courante =
3959: instruction_courante;
3960: return(d_erreur);
3961: }
3962:
3963: free(message);
3964:
3965: while((*(*s_etat_processus).l_base_pile_systeme)
3966: .clause != 'R')
3967: {
3968: l_registre_atome = l_element_courant;
3969: l_element_courant =
3970: (*l_element_courant).suivant;
3971:
3972: if (l_element_courant == NULL)
3973: {
3974: /*
3975: * La fin de l'expression est atteinte,
3976: * le sequenceur reprend la main.
3977: */
3978:
3979: if (presence_egalite == d_vrai)
3980: {
3981: liberation(s_etat_processus,
3982: s_objet_evalue);
3983: }
3984:
3985: (*s_etat_processus)
3986: .mode_execution_programme =
3987: registre_mode_execution_programme;
3988: return(d_absence_erreur);
3989: }
3990:
3991: if ((*(*l_element_courant).donnee).type == FCT)
3992: {
3993: (*s_etat_processus).instruction_courante =
3994: (*((struct_fonction *)
3995: (*(*l_element_courant).donnee)
3996: .objet)).nom_fonction;
3997:
3998: if (recherche_variable(s_etat_processus,
3999: (*s_etat_processus)
4000: .instruction_courante) == d_faux)
4001: {
4002: (*s_etat_processus).erreur_systeme
4003: = d_es;
4004: fonction = (*((struct_fonction *)
4005: (*(*l_element_courant).donnee)
4006: .objet)).fonction;
4007:
4008: /*
4009: * Traitement de la pile système par les
4010: * différentes instructions.
4011: */
4012:
4013: if (TEST(instruction_if) ||
4014: TEST(instruction_iferr) ||
4015: TEST(instruction_do) ||
4016: TEST(instruction_while) ||
4017: TEST(instruction_for) ||
4018: TEST(instruction_forall) ||
4019: TEST(instruction_start) ||
4020: TEST(instruction_select) ||
4021: TEST(instruction_case) ||
4022: TEST(instruction_critical) ||
4023: TEST(vers_niveau_superieur))
4024: {
4025: if (TEST(vers_niveau_superieur))
4026: {
4027: registre_exception =
4028: (*s_etat_processus)
4029: .exception;
4030: registre_erreur_execution =
4031: (*s_etat_processus)
4032: .erreur_execution;
4033:
4034: analyse(s_etat_processus,
4035: vers_niveau_superieur);
4036:
4037: if ((*s_etat_processus)
4038: .erreur_systeme != d_es)
4039: {
4040: if (presence_egalite ==
4041: d_vrai)
4042: {
4043: liberation(
4044: s_etat_processus,
4045: s_objet_evalue);
4046: }
4047:
4048: (*s_etat_processus)
4049: .instruction_courante =
4050: instruction_courante;
4051: return(d_erreur);
4052: }
4053:
4054: (*s_etat_processus).exception
4055: = registre_exception;
4056: (*s_etat_processus)
4057: .erreur_execution =
4058: registre_erreur_execution;
4059: }
4060: else if (TEST(instruction_for) ||
4061: TEST(instruction_forall) ||
4062: TEST(instruction_start))
4063: {
4064: empilement_pile_systeme(
4065: s_etat_processus);
4066:
4067: if ((*s_etat_processus)
4068: .erreur_systeme != d_es)
4069: {
4070: if (presence_egalite ==
4071: d_vrai)
4072: {
4073: liberation(
4074: s_etat_processus,
4075: s_objet_evalue);
4076: }
4077:
4078: (*s_etat_processus)
4079: .instruction_courante =
4080: instruction_courante;
4081: return(d_erreur);
4082: }
4083:
4084: (*(*s_etat_processus)
4085: .l_base_pile_systeme)
4086: .type_cloture = 'L';
4087: }
4088: else
4089: {
4090: empilement_pile_systeme(
4091: s_etat_processus);
4092:
4093: if ((*s_etat_processus)
4094: .erreur_systeme != d_es)
4095: {
4096: if (presence_egalite ==
4097: d_vrai)
4098: {
4099: liberation(
4100: s_etat_processus,
4101: s_objet_evalue);
4102: }
4103:
4104: (*s_etat_processus)
4105: .instruction_courante =
4106: instruction_courante;
4107: return(d_erreur);
4108: }
4109: }
4110: }
4111: else if (TEST(instruction_end) ||
4112: TEST(instruction_next) ||
4113: TEST(instruction_step) ||
4114: TEST(vers_niveau_inferieur))
4115: {
4116: if (TEST(vers_niveau_inferieur))
4117: {
4118: registre_exception =
4119: (*s_etat_processus)
4120: .exception;
4121: registre_erreur_execution =
4122: (*s_etat_processus)
4123: .erreur_execution;
4124:
4125: analyse(s_etat_processus,
4126: vers_niveau_inferieur);
4127:
4128: if ((*s_etat_processus)
4129: .erreur_systeme != d_es)
4130: {
4131: if (presence_egalite ==
4132: d_vrai)
4133: {
4134: liberation(
4135: s_etat_processus,
4136: s_objet_evalue);
4137: }
4138:
4139: (*s_etat_processus)
4140: .instruction_courante =
4141: instruction_courante;
4142: return(d_erreur);
4143: }
4144:
4145: (*s_etat_processus).exception
4146: = registre_exception;
4147: (*s_etat_processus)
4148: .erreur_execution =
4149: registre_erreur_execution;
4150: }
4151: else if ((TEST(instruction_next) ||
4152: TEST(instruction_step)) &&
4153: ((*(*s_etat_processus)
4154: .l_base_pile_systeme)
4155: .type_cloture != 'L'))
4156: {
4157: /*
4158: * Libération des compteurs
4159: * de boucle
4160: */
4161:
4162: presence_compteur =
4163: (((*(*s_etat_processus)
4164: .l_base_pile_systeme)
4165: .type_cloture == 'F') ||
4166: ((*(*s_etat_processus)
4167: .l_base_pile_systeme)
4168: .type_cloture == 'A'))
4169: ? d_vrai : d_faux;
4170:
4171: if (((*(*s_etat_processus)
4172: .l_base_pile_systeme)
4173: .type_cloture != 'S') &&
4174: (presence_compteur ==
4175: d_faux))
4176: {
4177: (*s_etat_processus)
4178: .erreur_execution =
4179: d_ex_erreur_traitement_boucle;
4180:
4181: if (presence_egalite ==
4182: d_vrai)
4183: {
4184: liberation(
4185: s_etat_processus,
4186: s_objet_evalue);
4187: }
4188:
4189: (*s_etat_processus)
4190: .instruction_courante =
4191: instruction_courante;
4192: return(d_erreur);
4193: }
4194:
4195: if (presence_compteur == d_vrai)
4196: {
4197: if (recherche_variable(
4198: s_etat_processus,
4199: (*(*s_etat_processus)
4200: .l_base_pile_systeme)
4201: .nom_variable) ==
4202: d_faux)
4203: {
4204: (*s_etat_processus)
4205: .erreur_systeme = d_es;
4206: (*s_etat_processus)
4207: .erreur_execution =
4208: d_ex_erreur_traitement_boucle;
4209:
4210: if (presence_egalite ==
4211: d_vrai)
4212: {
4213: liberation(
4214: s_etat_processus,
4215: s_objet_evalue);
4216: }
4217:
4218: (*s_etat_processus)
4219: .instruction_courante =
4220: instruction_courante;
4221: return(d_erreur);
4222: }
4223:
4224: if ((*(*s_etat_processus)
4225: .pointeur_variable_courante)
4226: .objet == NULL)
4227: {
4228: (*s_etat_processus)
4229: .erreur_systeme = d_es;
4230: (*s_etat_processus)
4231: .erreur_execution =
4232: d_ex_variable_partagee;
4233:
4234: if (presence_egalite ==
4235: d_vrai)
4236: {
4237: liberation(
4238: s_etat_processus,
4239: s_objet_evalue);
4240: }
4241:
4242: (*s_etat_processus)
4243: .instruction_courante =
4244: instruction_courante;
4245: return(d_erreur);
4246: }
4247:
4248: (*s_etat_processus)
4249: .niveau_courant--;
4250:
4251: if (
4252: retrait_variables_par_niveau(
4253: s_etat_processus) == d_erreur)
4254: {
4255: if (presence_egalite ==
4256: d_vrai)
4257: {
4258: liberation(
4259: s_etat_processus,
4260: s_objet_evalue);
4261: }
4262:
4263: (*s_etat_processus)
4264: .instruction_courante =
4265: instruction_courante;
4266: return(d_erreur);
4267: }
4268: }
4269:
4270: depilement_pile_systeme(
4271: s_etat_processus);
4272: }
4273: else
4274: {
4275: // Traitement spécifique pour la
4276: // fin d'une section critique
4277:
4278: if ((*s_etat_processus)
4279: .l_base_pile_systeme ==
4280: NULL)
4281: {
4282: (*s_etat_processus)
4283: .erreur_systeme =
4284: d_es_end_incoherent;
4285:
4286: if (presence_egalite ==
4287: d_vrai)
4288: {
4289: liberation(
4290: s_etat_processus,
4291: s_objet_evalue);
4292: }
4293:
4294: (*s_etat_processus)
4295: .instruction_courante =
4296: instruction_courante;
4297: return(d_erreur);
4298: }
4299:
4300: if ((*(*s_etat_processus)
4301: .l_base_pile_systeme)
4302: .type_cloture == 'Q')
4303: {
4304: if (pthread_mutex_unlock(
4305: &mutex_sections_critiques)
4306: != 0)
4307: {
4308: (*s_etat_processus)
4309: .erreur_systeme =
4310: d_es_processus;
4311:
4312: if (presence_egalite ==
4313: d_vrai)
4314: {
4315: liberation(
4316: s_etat_processus,
4317: s_objet_evalue);
4318: }
4319:
4320: (*s_etat_processus)
4321: .instruction_courante =
4322: instruction_courante;
4323: return(d_erreur);
4324: }
4325:
4326: (*s_etat_processus)
4327: .sections_critiques--;
4328: }
4329:
4330: depilement_pile_systeme(
4331: s_etat_processus);
4332:
4333: if ((*s_etat_processus)
4334: .erreur_systeme != d_es)
4335: {
4336: if (presence_egalite ==
4337: d_vrai)
4338: {
4339: liberation(
4340: s_etat_processus,
4341: s_objet_evalue);
4342: }
4343:
4344: (*s_etat_processus)
4345: .instruction_courante =
4346: instruction_courante;
4347: return(d_erreur);
4348: }
4349: }
4350: }
4351: }
4352: }
4353: }
4354:
4355: (*s_etat_processus).instruction_courante =
4356: instruction_courante;
4357: drapeau_then = d_faux;
4358:
4359: do
4360: {
4361: l_registre_atome = l_element_courant;
4362:
4363: if (l_element_courant == NULL)
4364: {
4365: /*
4366: * La fin de l'expression est atteinte,
4367: * le sequenceur reprend la main.
4368: */
4369:
4370: if (presence_egalite == d_vrai)
4371: {
4372: liberation(s_etat_processus,
4373: s_objet_evalue);
4374: }
4375:
4376: (*s_etat_processus)
4377: .mode_execution_programme =
4378: registre_mode_execution_programme;
4379: (*s_etat_processus).instruction_courante =
4380: instruction_courante;
4381: return(d_absence_erreur);
4382: }
4383:
4384: if ((*(*l_element_courant).donnee).type == FCT)
4385: {
4386: (*s_etat_processus)
4387: .instruction_courante =
4388: (*((struct_fonction *)
4389: (*(*l_element_courant).donnee)
4390: .objet)).nom_fonction;
4391: fonction = (*((struct_fonction *)
4392: (*(*l_element_courant).donnee)
4393: .objet)).fonction;
4394: (*s_etat_processus).instruction_courante =
4395: instruction_courante;
4396:
4397: drapeau_then = TEST(instruction_then)
4398: ? d_vrai : d_faux;
4399: }
4400:
4401: l_element_courant = (*l_element_courant)
4402: .suivant;
4403: } while(drapeau_then == d_faux);
4404:
4405: (*s_etat_processus).expression_courante =
4406: l_registre_atome;
4407:
4408: (*(*s_etat_processus).l_base_pile_systeme)
4409: .clause = 'X';
4410: instruction_then(s_etat_processus);
4411:
4412: (*s_etat_processus).exception = d_ep;
4413: (*s_etat_processus).erreur_execution = d_ex;
4414: }
4415: else if ((*s_etat_processus).mode_evaluation_expression
4416: == 'Y')
4417: {
4418: /*
4419: * Reprise sur erreur
4420: */
4421:
4422: while(l_element_courant != NULL)
4423: {
4424: if ((*(*l_element_courant).donnee).type == FCT)
4425: {
4426: (*s_etat_processus).instruction_courante =
4427: (*((struct_fonction *)
4428: (*(*l_element_courant).donnee)
4429: .objet)).nom_fonction;
4430: fonction = (*((struct_fonction *)
4431: (*(*l_element_courant).donnee)
4432: .objet)).fonction;
4433:
4434: if (recherche_variable(s_etat_processus,
4435: (*s_etat_processus)
4436: .instruction_courante) == d_faux)
4437: {
4438: (*s_etat_processus).erreur_systeme
4439: = d_es;
4440:
4441: /*
4442: * Traitement de la pile système par les
4443: * différentes instructions.
4444: */
4445:
4446: if (TEST(instruction_if) ||
4447: TEST(instruction_iferr) ||
4448: TEST(instruction_do) ||
4449: TEST(instruction_while) ||
4450: TEST(instruction_for) ||
4451: TEST(instruction_forall) ||
4452: TEST(instruction_start) ||
4453: TEST(instruction_select) ||
4454: TEST(instruction_case) ||
4455: TEST(instruction_critical) ||
4456: TEST(vers_niveau_superieur))
4457: {
4458: if (TEST(vers_niveau_superieur))
4459: {
4460: analyse(s_etat_processus,
4461: vers_niveau_superieur);
4462:
4463: if ((*s_etat_processus)
4464: .erreur_systeme != d_es)
4465: {
4466: if (presence_egalite ==
4467: d_vrai)
4468: {
4469: liberation(
4470: s_etat_processus,
4471: s_objet_evalue);
4472: }
4473:
4474: (*s_etat_processus)
4475: .instruction_courante =
4476: instruction_courante;
4477: return(d_erreur);
4478: }
4479: }
4480: else if (TEST(instruction_for) ||
4481: TEST(instruction_forall) ||
4482: TEST(instruction_start))
4483: {
4484: empilement_pile_systeme(
4485: s_etat_processus);
4486:
4487: if ((*s_etat_processus)
4488: .erreur_systeme != d_es)
4489: {
4490: if (presence_egalite ==
4491: d_vrai)
4492: {
4493: liberation(
4494: s_etat_processus,
4495: s_objet_evalue);
4496: }
4497:
4498: (*s_etat_processus)
4499: .instruction_courante =
4500: instruction_courante;
4501: return(d_erreur);
4502: }
4503:
4504: (*(*s_etat_processus)
4505: .l_base_pile_systeme)
4506: .type_cloture = 'L';
4507: }
4508: else
4509: {
4510: empilement_pile_systeme(
4511: s_etat_processus);
4512:
4513: if ((*s_etat_processus)
4514: .erreur_systeme != d_es)
4515: {
4516: if (presence_egalite ==
4517: d_vrai)
4518: {
4519: liberation(
4520: s_etat_processus,
4521: s_objet_evalue);
4522: }
4523:
4524: (*s_etat_processus)
4525: .instruction_courante =
4526: instruction_courante;
4527: return(d_erreur);
4528: }
4529: }
4530: }
4531: else if (TEST(instruction_end) ||
4532: TEST(instruction_next) ||
4533: TEST(instruction_step) ||
4534: TEST(vers_niveau_inferieur))
4535: {
4536: if (TEST(vers_niveau_inferieur))
4537: {
4538: analyse(s_etat_processus,
4539: vers_niveau_inferieur);
4540:
4541: if ((*s_etat_processus)
4542: .erreur_systeme != d_es)
4543: {
4544: if (presence_egalite ==
4545: d_vrai)
4546: {
4547: liberation(
4548: s_etat_processus,
4549: s_objet_evalue);
4550: }
4551:
4552: (*s_etat_processus)
4553: .instruction_courante =
4554: instruction_courante;
4555: return(d_erreur);
4556: }
4557: }
4558: else if ((TEST(instruction_next) ||
4559: TEST(instruction_step)) &&
4560: ((*(*s_etat_processus)
4561: .l_base_pile_systeme)
4562: .type_cloture != 'L'))
4563: {
4564: /*
4565: * Libération des compteurs
4566: * de boucle
4567: */
4568:
4569: presence_compteur =
4570: (((*(*s_etat_processus)
4571: .l_base_pile_systeme)
4572: .type_cloture == 'F') ||
4573: ((*(*s_etat_processus)
4574: .l_base_pile_systeme)
4575: .type_cloture == 'A'))
4576: ? d_vrai : d_faux;
4577:
4578: if (((*(*s_etat_processus)
4579: .l_base_pile_systeme)
4580: .type_cloture != 'S') &&
4581: (presence_compteur ==
4582: d_faux))
4583: {
4584: (*s_etat_processus)
4585: .erreur_execution =
4586: d_ex_erreur_traitement_boucle;
4587:
4588: if (presence_egalite ==
4589: d_vrai)
4590: {
4591: liberation(
4592: s_etat_processus,
4593: s_objet_evalue);
4594: }
4595:
4596: (*s_etat_processus)
4597: .instruction_courante =
4598: instruction_courante;
4599: return(d_erreur);
4600: }
4601:
4602: if (presence_compteur == d_vrai)
4603: {
4604: if (recherche_variable(
4605: s_etat_processus,
4606: (*(*s_etat_processus)
4607: .l_base_pile_systeme)
4608: .nom_variable) ==
4609: d_faux)
4610: {
4611: (*s_etat_processus)
4612: .erreur_systeme = d_es;
4613: (*s_etat_processus)
4614: .erreur_execution =
4615: d_ex_erreur_traitement_boucle;
4616:
4617: if (presence_egalite ==
4618: d_vrai)
4619: {
4620: liberation(
4621: s_etat_processus,
4622: s_objet_evalue);
4623: }
4624:
4625: (*s_etat_processus)
4626: .instruction_courante =
4627: instruction_courante;
4628: return(d_erreur);
4629: }
4630:
4631: if ((*(*s_etat_processus)
4632: .pointeur_variable_courante)
4633: .objet == NULL)
4634: {
4635: (*s_etat_processus)
4636: .erreur_systeme = d_es;
4637: (*s_etat_processus)
4638: .erreur_execution =
4639: d_ex_variable_partagee;
4640:
4641: if (presence_egalite ==
4642: d_vrai)
4643: {
4644: liberation(
4645: s_etat_processus,
4646: s_objet_evalue);
4647: }
4648:
4649: (*s_etat_processus)
4650: .instruction_courante =
4651: instruction_courante;
4652: return(d_erreur);
4653: }
4654:
4655: (*s_etat_processus)
4656: .niveau_courant--;
4657:
4658: if (
4659: retrait_variables_par_niveau(
4660: s_etat_processus) == d_erreur)
4661: {
4662: if (presence_egalite ==
4663: d_vrai)
4664: {
4665: liberation(
4666: s_etat_processus,
4667: s_objet_evalue);
4668: }
4669:
4670: (*s_etat_processus)
4671: .instruction_courante =
4672: instruction_courante;
4673: return(d_erreur);
4674: }
4675: }
4676:
4677: depilement_pile_systeme(
4678: s_etat_processus);
4679: }
4680: else
4681: {
4682: // Traitement spécifique pour la
4683: // fin d'une section critique
4684:
4685: if ((*s_etat_processus)
4686: .l_base_pile_systeme ==
4687: NULL)
4688: {
4689: (*s_etat_processus)
4690: .erreur_systeme =
4691: d_es_end_incoherent;
4692:
4693: if (presence_egalite ==
4694: d_vrai)
4695: {
4696: liberation(
4697: s_etat_processus,
4698: s_objet_evalue);
4699: }
4700:
4701: (*s_etat_processus)
4702: .instruction_courante =
4703: instruction_courante;
4704: return(d_erreur);
4705: }
4706:
4707: if ((*(*s_etat_processus)
4708: .l_base_pile_systeme)
4709: .type_cloture == 'Q')
4710: {
4711: if (pthread_mutex_unlock(
4712: &mutex_sections_critiques)
4713: != 0)
4714: {
4715: (*s_etat_processus)
4716: .erreur_systeme =
4717: d_es_processus;
4718:
4719: if (presence_egalite ==
4720: d_vrai)
4721: {
4722: liberation(
4723: s_etat_processus,
4724: s_objet_evalue);
4725: }
4726:
4727: (*s_etat_processus)
4728: .instruction_courante =
4729: instruction_courante;
4730: return(d_erreur);
4731: }
4732:
4733: (*s_etat_processus)
4734: .sections_critiques--;
4735: }
4736:
4737: depilement_pile_systeme(
4738: s_etat_processus);
4739:
4740: if ((*s_etat_processus)
4741: .erreur_systeme != d_es)
4742: {
4743: if (presence_egalite ==
4744: d_vrai)
4745: {
4746: liberation(
4747: s_etat_processus,
4748: s_objet_evalue);
4749: }
4750:
4751: (*s_etat_processus)
4752: .instruction_courante =
4753: instruction_courante;
4754: return(d_erreur);
4755: }
4756: }
4757: }
4758: }
4759: }
4760:
4761: l_element_courant =
4762: (*l_element_courant).suivant;
4763: }
4764:
4765: (*s_etat_processus).mode_execution_programme =
4766: registre_mode_execution_programme;
4767: (*s_etat_processus).instruction_courante =
4768: instruction_courante;
4769:
4770: (*s_etat_processus).exception = d_ep;
4771: (*s_etat_processus).erreur_execution = d_ex;
4772:
4773: erreur_evaluation = d_erreur;
4774: }
4775: else
4776: {
4777: // On ne détruit pas les variables pour les inclure
4778: // dans le fichier rpl-core.
4779:
4780: (*s_etat_processus).gel_liste_variables = d_vrai;
4781:
4782: registre_erreur_execution =
4783: (*s_etat_processus).erreur_execution;
4784: registre_exception =
4785: (*s_etat_processus).exception;
4786: registre_erreur_systeme =
4787: (*s_etat_processus).erreur_systeme;
4788:
4789: (*s_etat_processus).s_objet_errone = s_objet;
4790: (*s_etat_processus).s_objet_erreur =
4791: (*l_element_courant).donnee;
4792:
4793: l_element_courant = (*l_element_courant).suivant;
4794:
4795: while(l_element_courant != NULL)
4796: {
4797: if ((*(*l_element_courant).donnee).type == FCT)
4798: {
4799: (*s_etat_processus).instruction_courante =
4800: (*((struct_fonction *)
4801: (*(*l_element_courant).donnee)
4802: .objet)).nom_fonction;
4803: fonction = (*((struct_fonction *)
4804: (*(*l_element_courant).donnee)
4805: .objet)).fonction;
4806:
4807: if (recherche_variable(s_etat_processus,
4808: (*s_etat_processus)
4809: .instruction_courante) == d_faux)
4810: {
4811: (*s_etat_processus).erreur_systeme
4812: = d_es;
4813:
4814: /*
4815: * Traitement de la pile système par les
4816: * différentes instructions.
4817: */
4818:
4819: if (TEST(instruction_if) ||
4820: TEST(instruction_iferr) ||
4821: TEST(instruction_do) ||
4822: TEST(instruction_while) ||
4823: TEST(instruction_for) ||
4824: TEST(instruction_forall) ||
4825: TEST(instruction_start) ||
4826: TEST(instruction_select) ||
4827: TEST(instruction_case) ||
4828: TEST(instruction_critical) ||
4829: TEST(vers_niveau_superieur))
4830: {
4831: if (TEST(vers_niveau_superieur))
4832: {
4833: analyse(s_etat_processus,
4834: vers_niveau_superieur);
4835:
4836: if ((*s_etat_processus)
4837: .erreur_systeme != d_es)
4838: {
4839: if (presence_egalite ==
4840: d_vrai)
4841: {
4842: liberation(
4843: s_etat_processus,
4844: s_objet_evalue);
4845: }
4846:
4847: (*s_etat_processus)
4848: .instruction_courante =
4849: instruction_courante;
4850: return(d_erreur);
4851: }
4852: }
4853: else if (TEST(instruction_for) ||
4854: TEST(instruction_forall) ||
4855: TEST(instruction_start))
4856: {
4857: empilement_pile_systeme(
4858: s_etat_processus);
4859:
4860: if ((*s_etat_processus)
4861: .erreur_systeme != d_es)
4862: {
4863: if (presence_egalite ==
4864: d_vrai)
4865: {
4866: liberation(
4867: s_etat_processus,
4868: s_objet_evalue);
4869: }
4870:
4871: (*s_etat_processus)
4872: .instruction_courante =
4873: instruction_courante;
4874: return(d_erreur);
4875: }
4876:
4877: (*(*s_etat_processus)
4878: .l_base_pile_systeme)
4879: .type_cloture = 'L';
4880: }
4881: else
4882: {
4883: empilement_pile_systeme(
4884: s_etat_processus);
4885:
4886: if ((*s_etat_processus)
4887: .erreur_systeme != d_es)
4888: {
4889: if (presence_egalite ==
4890: d_vrai)
4891: {
4892: liberation(
4893: s_etat_processus,
4894: s_objet_evalue);
4895: }
4896:
4897: (*s_etat_processus)
4898: .instruction_courante =
4899: instruction_courante;
4900: return(d_erreur);
4901: }
4902: }
4903: }
4904: else if (TEST(instruction_end) ||
4905: TEST(instruction_next) ||
4906: TEST(instruction_step) ||
4907: TEST(vers_niveau_inferieur))
4908: {
4909: if (TEST(vers_niveau_inferieur))
4910: {
4911: analyse(s_etat_processus,
4912: vers_niveau_inferieur);
4913:
4914: if ((*s_etat_processus)
4915: .erreur_systeme != d_es)
4916: {
4917: if (presence_egalite ==
4918: d_vrai)
4919: {
4920: liberation(
4921: s_etat_processus,
4922: s_objet_evalue);
4923: }
4924:
4925: (*s_etat_processus)
4926: .instruction_courante =
4927: instruction_courante;
4928: return(d_erreur);
4929: }
4930: }
4931: else if ((TEST(instruction_next) ||
4932: TEST(instruction_step)) &&
4933: ((*(*s_etat_processus)
4934: .l_base_pile_systeme)
4935: .type_cloture != 'L'))
4936: {
4937: /*
4938: * Libération des compteurs
4939: * de boucle
4940: */
4941:
4942: presence_compteur =
4943: (((*(*s_etat_processus)
4944: .l_base_pile_systeme)
4945: .type_cloture == 'F') ||
4946: ((*(*s_etat_processus)
4947: .l_base_pile_systeme)
4948: .type_cloture == 'A'))
4949: ? d_vrai : d_faux;
4950:
4951: if (((*(*s_etat_processus)
4952: .l_base_pile_systeme)
4953: .type_cloture != 'S') &&
4954: (presence_compteur ==
4955: d_faux))
4956: {
4957: (*s_etat_processus)
4958: .erreur_execution =
4959: d_ex_erreur_traitement_boucle;
4960:
4961: if (presence_egalite ==
4962: d_vrai)
4963: {
4964: liberation(
4965: s_etat_processus,
4966: s_objet_evalue);
4967: }
4968:
4969: (*s_etat_processus)
4970: .instruction_courante =
4971: instruction_courante;
4972: return(d_erreur);
4973: }
4974:
4975: if (presence_compteur == d_vrai)
4976: {
4977: if (recherche_variable(
4978: s_etat_processus,
4979: (*(*s_etat_processus)
4980: .l_base_pile_systeme)
4981: .nom_variable) ==
4982: d_faux)
4983: {
4984: (*s_etat_processus)
4985: .erreur_systeme = d_es;
4986: (*s_etat_processus)
4987: .erreur_execution =
4988: d_ex_erreur_traitement_boucle;
4989:
4990: if (presence_egalite ==
4991: d_vrai)
4992: {
4993: liberation(
4994: s_etat_processus,
4995: s_objet_evalue);
4996: }
4997:
4998: (*s_etat_processus)
4999: .instruction_courante =
5000: instruction_courante;
5001: return(d_erreur);
5002: }
5003:
5004: if ((*(*s_etat_processus)
5005: .pointeur_variable_courante)
5006: .objet == NULL)
5007: {
5008: (*s_etat_processus)
5009: .erreur_systeme = d_es;
5010: (*s_etat_processus)
5011: .erreur_execution =
5012: d_ex_variable_partagee;
5013:
5014: if (presence_egalite ==
5015: d_vrai)
5016: {
5017: liberation(
5018: s_etat_processus,
5019: s_objet_evalue);
5020: }
5021:
5022: (*s_etat_processus)
5023: .instruction_courante =
5024: instruction_courante;
5025: return(d_erreur);
5026: }
5027:
5028: (*s_etat_processus)
5029: .niveau_courant--;
5030:
5031: if (
5032: retrait_variables_par_niveau(
5033: s_etat_processus) == d_erreur)
5034: {
5035: if (presence_egalite ==
5036: d_vrai)
5037: {
5038: liberation(
5039: s_etat_processus,
5040: s_objet_evalue);
5041: }
5042:
5043: (*s_etat_processus)
5044: .instruction_courante =
5045: instruction_courante;
5046: return(d_erreur);
5047: }
5048: }
5049:
5050: depilement_pile_systeme(
5051: s_etat_processus);
5052: }
5053: else
5054: {
5055: // Traitement spécifique pour la
5056: // fin d'une section critique
5057:
5058: if ((*s_etat_processus)
5059: .l_base_pile_systeme ==
5060: NULL)
5061: {
5062: (*s_etat_processus)
5063: .erreur_systeme =
5064: d_es_end_incoherent;
5065:
5066: if (presence_egalite ==
5067: d_vrai)
5068: {
5069: liberation(
5070: s_etat_processus,
5071: s_objet_evalue);
5072: }
5073:
5074: (*s_etat_processus)
5075: .instruction_courante =
5076: instruction_courante;
5077: return(d_erreur);
5078: }
5079:
5080: if ((*(*s_etat_processus)
5081: .l_base_pile_systeme)
5082: .type_cloture == 'Q')
5083: {
5084: if (pthread_mutex_unlock(
5085: &mutex_sections_critiques)
5086: != 0)
5087: {
5088: (*s_etat_processus)
5089: .erreur_systeme =
5090: d_es_processus;
5091:
5092: if (presence_egalite ==
5093: d_vrai)
5094: {
5095: liberation(
5096: s_etat_processus,
5097: s_objet_evalue);
5098: }
5099:
5100: (*s_etat_processus)
5101: .instruction_courante =
5102: instruction_courante;
5103: return(d_erreur);
5104: }
5105:
5106: (*s_etat_processus)
5107: .sections_critiques--;
5108: }
5109:
5110: depilement_pile_systeme(
5111: s_etat_processus);
5112:
5113: if ((*s_etat_processus)
5114: .erreur_systeme != d_es)
5115: {
5116: if (presence_egalite ==
5117: d_vrai)
5118: {
5119: liberation(
5120: s_etat_processus,
5121: s_objet_evalue);
5122: }
5123:
5124: (*s_etat_processus)
5125: .instruction_courante =
5126: instruction_courante;
5127: return(d_erreur);
5128: }
5129: }
5130: }
5131: }
5132: }
5133:
5134: l_element_courant =
5135: (*l_element_courant).suivant;
5136: }
5137:
5138: (*s_etat_processus).mode_execution_programme =
5139: registre_mode_execution_programme;
5140: (*s_etat_processus).instruction_courante =
5141: instruction_courante;
5142:
5143: if (presence_egalite == d_vrai)
5144: {
5145: liberation(s_etat_processus, s_objet_evalue);
5146: }
5147:
5148: if ((*s_etat_processus)
5149: .var_volatile_processus_pere == 0)
5150: {
5151: envoi_signal_processus((*s_etat_processus)
5152: .pid_processus_pere, rpl_sigalrm);
5153: }
5154: else
5155: {
5156: (*s_etat_processus).var_volatile_alarme = -1;
5157: }
5158:
5159: (*s_etat_processus).erreur_execution =
5160: registre_erreur_execution;
5161: (*s_etat_processus).erreur_systeme =
5162: registre_erreur_systeme;
5163: (*s_etat_processus).exception =
5164: registre_exception;
5165: return(d_erreur);
5166: }
5167: }
5168:
5169: if ((*s_etat_processus).erreur_systeme != d_es)
5170: {
5171: if (presence_egalite == d_vrai)
5172: {
5173: liberation(s_etat_processus, s_objet_evalue);
5174: }
5175:
5176: if ((*s_etat_processus).var_volatile_processus_pere
5177: == 0)
5178: {
5179: envoi_signal_processus((*s_etat_processus)
5180: .pid_processus_pere, rpl_sigalrm);
5181: }
5182: else
5183: {
5184: (*s_etat_processus).var_volatile_alarme = -1;
5185: }
5186:
5187: (*s_etat_processus).instruction_courante =
5188: instruction_courante;
5189: return(d_erreur);
5190: }
5191: else if (((*s_etat_processus).erreur_execution != d_ex) ||
5192: ((*s_etat_processus).exception != d_ep))
5193: {
5194: if ((*s_etat_processus).arret_si_exception == d_faux)
5195: {
5196: /*
5197: * Reprise sur erreur
5198: */
5199:
5200: if ((message = messages(s_etat_processus)) == NULL)
5201: {
5202: if (presence_egalite == d_vrai)
5203: {
5204: liberation(s_etat_processus,
5205: s_objet_evalue);
5206: }
5207:
5208: (*s_etat_processus).instruction_courante =
5209: instruction_courante;
5210: return(d_erreur);
5211: }
5212:
5213: free(message);
5214:
5215: while((*(*s_etat_processus).l_base_pile_systeme)
5216: .clause != 'R')
5217: {
5218: l_registre_atome = l_element_courant;
5219: l_element_courant =
5220: (*l_element_courant).suivant;
5221:
5222: if (l_element_courant == NULL)
5223: {
5224: /*
5225: * La fin de l'expression est atteinte,
5226: * le sequenceur reprend la main.
5227: */
5228:
5229: if (presence_egalite == d_vrai)
5230: {
5231: liberation(s_etat_processus,
5232: s_objet_evalue);
5233: }
5234:
5235: (*s_etat_processus)
5236: .mode_execution_programme =
5237: registre_mode_execution_programme;
5238: return(d_absence_erreur);
5239: }
5240:
5241: if ((*(*l_element_courant).donnee).type == FCT)
5242: {
5243: (*s_etat_processus).instruction_courante =
5244: (*((struct_fonction *)
5245: (*(*l_element_courant).donnee)
5246: .objet)).nom_fonction;
5247:
5248: if (recherche_variable(s_etat_processus,
5249: (*s_etat_processus)
5250: .instruction_courante) == d_faux)
5251: {
5252: (*s_etat_processus).erreur_systeme
5253: = d_es;
5254: fonction = (*((struct_fonction *)
5255: (*(*l_element_courant).donnee)
5256: .objet)).fonction;
5257:
5258: /*
5259: * Traitement de la pile système par les
5260: * différentes instructions.
5261: */
5262:
5263: if (TEST(instruction_if) ||
5264: TEST(instruction_iferr) ||
5265: TEST(instruction_do) ||
5266: TEST(instruction_while) ||
5267: TEST(instruction_for) ||
5268: TEST(instruction_forall) ||
5269: TEST(instruction_start) ||
5270: TEST(instruction_select) ||
5271: TEST(instruction_case) ||
5272: TEST(instruction_critical) ||
5273: TEST(vers_niveau_superieur))
5274: {
5275: if (TEST(vers_niveau_superieur))
5276: {
5277: registre_exception =
5278: (*s_etat_processus)
5279: .exception;
5280: registre_erreur_execution =
5281: (*s_etat_processus)
5282: .erreur_execution;
5283:
5284: analyse(s_etat_processus,
5285: vers_niveau_superieur);
5286:
5287: if ((*s_etat_processus)
5288: .erreur_systeme != d_es)
5289: {
5290: if (presence_egalite ==
5291: d_vrai)
5292: {
5293: liberation(
5294: s_etat_processus,
5295: s_objet_evalue);
5296: }
5297:
5298: (*s_etat_processus)
5299: .instruction_courante =
5300: instruction_courante;
5301: return(d_erreur);
5302: }
5303:
5304: (*s_etat_processus).exception
5305: = registre_exception;
5306: (*s_etat_processus)
5307: .erreur_execution =
5308: registre_erreur_execution;
5309: }
5310: else if (TEST(instruction_for) ||
5311: TEST(instruction_forall) ||
5312: TEST(instruction_start))
5313: {
5314: empilement_pile_systeme(
5315: s_etat_processus);
5316:
5317: if ((*s_etat_processus)
5318: .erreur_systeme != d_es)
5319: {
5320: if (presence_egalite ==
5321: d_vrai)
5322: {
5323: liberation(
5324: s_etat_processus,
5325: s_objet_evalue);
5326: }
5327:
5328: (*s_etat_processus)
5329: .instruction_courante =
5330: instruction_courante;
5331: return(d_erreur);
5332: }
5333:
5334: (*(*s_etat_processus)
5335: .l_base_pile_systeme)
5336: .type_cloture = 'L';
5337: }
5338: else
5339: {
5340: empilement_pile_systeme(
5341: s_etat_processus);
5342:
5343: if ((*s_etat_processus)
5344: .erreur_systeme != d_es)
5345: {
5346: if (presence_egalite ==
5347: d_vrai)
5348: {
5349: liberation(
5350: s_etat_processus,
5351: s_objet_evalue);
5352: }
5353:
5354: (*s_etat_processus)
5355: .instruction_courante =
5356: instruction_courante;
5357: return(d_erreur);
5358: }
5359: }
5360: }
5361: else if (TEST(instruction_end) ||
5362: TEST(instruction_next) ||
5363: TEST(instruction_step) ||
5364: TEST(vers_niveau_inferieur))
5365: {
5366: if (TEST(vers_niveau_inferieur))
5367: {
5368: registre_exception =
5369: (*s_etat_processus)
5370: .exception;
5371: registre_erreur_execution =
5372: (*s_etat_processus)
5373: .erreur_execution;
5374:
5375: analyse(s_etat_processus,
5376: vers_niveau_inferieur);
5377:
5378: if ((*s_etat_processus)
5379: .erreur_systeme != d_es)
5380: {
5381: if (presence_egalite ==
5382: d_vrai)
5383: {
5384: liberation(
5385: s_etat_processus,
5386: s_objet_evalue);
5387: }
5388:
5389: (*s_etat_processus)
5390: .instruction_courante =
5391: instruction_courante;
5392: return(d_erreur);
5393: }
5394:
5395: (*s_etat_processus).exception
5396: = registre_exception;
5397: (*s_etat_processus)
5398: .erreur_execution =
5399: registre_erreur_execution;
5400: }
5401: else if ((TEST(instruction_next) ||
5402: TEST(instruction_step)) &&
5403: ((*(*s_etat_processus)
5404: .l_base_pile_systeme)
5405: .type_cloture != 'L'))
5406: {
5407: /*
5408: * Libération des compteurs
5409: * de boucle
5410: */
5411:
5412: presence_compteur =
5413: (((*(*s_etat_processus)
5414: .l_base_pile_systeme)
5415: .type_cloture == 'F') ||
5416: ((*(*s_etat_processus)
5417: .l_base_pile_systeme)
5418: .type_cloture == 'A'))
5419: ? d_vrai : d_faux;
5420:
5421: if (((*(*s_etat_processus)
5422: .l_base_pile_systeme)
5423: .type_cloture != 'S') &&
5424: (presence_compteur ==
5425: d_faux))
5426: {
5427: (*s_etat_processus)
5428: .erreur_execution =
5429: d_ex_erreur_traitement_boucle;
5430:
5431: if (presence_egalite ==
5432: d_vrai)
5433: {
5434: liberation(
5435: s_etat_processus,
5436: s_objet_evalue);
5437: }
5438:
5439: (*s_etat_processus)
5440: .instruction_courante =
5441: instruction_courante;
5442: return(d_erreur);
5443: }
5444:
5445: if (presence_compteur == d_vrai)
5446: {
5447: if (recherche_variable(
5448: s_etat_processus,
5449: (*(*s_etat_processus)
5450: .l_base_pile_systeme)
5451: .nom_variable) ==
5452: d_faux)
5453: {
5454: (*s_etat_processus)
5455: .erreur_systeme = d_es;
5456: (*s_etat_processus)
5457: .erreur_execution =
5458: d_ex_erreur_traitement_boucle;
5459:
5460: if (presence_egalite ==
5461: d_vrai)
5462: {
5463: liberation(
5464: s_etat_processus,
5465: s_objet_evalue);
5466: }
5467:
5468: (*s_etat_processus)
5469: .instruction_courante =
5470: instruction_courante;
5471: return(d_erreur);
5472: }
5473:
5474: if ((*(*s_etat_processus)
5475: .pointeur_variable_courante)
5476: .objet == NULL)
5477: {
5478: (*s_etat_processus)
5479: .erreur_systeme = d_es;
5480: (*s_etat_processus)
5481: .erreur_execution =
5482: d_ex_variable_partagee;
5483:
5484: if (presence_egalite ==
5485: d_vrai)
5486: {
5487: liberation(
5488: s_etat_processus,
5489: s_objet_evalue);
5490: }
5491:
5492: (*s_etat_processus)
5493: .instruction_courante =
5494: instruction_courante;
5495: return(d_erreur);
5496: }
5497:
5498: (*s_etat_processus)
5499: .niveau_courant--;
5500:
5501: if (
5502: retrait_variables_par_niveau(
5503: s_etat_processus) == d_erreur)
5504: {
5505: if (presence_egalite ==
5506: d_vrai)
5507: {
5508: liberation(
5509: s_etat_processus,
5510: s_objet_evalue);
5511: }
5512:
5513: (*s_etat_processus)
5514: .instruction_courante =
5515: instruction_courante;
5516: return(d_erreur);
5517: }
5518: }
5519:
5520: depilement_pile_systeme(
5521: s_etat_processus);
5522: }
5523: else
5524: {
5525: // Traitement spécifique pour la
5526: // fin d'une section critique
5527:
5528: if ((*s_etat_processus)
5529: .l_base_pile_systeme ==
5530: NULL)
5531: {
5532: (*s_etat_processus)
5533: .erreur_systeme =
5534: d_es_end_incoherent;
5535:
5536: if (presence_egalite ==
5537: d_vrai)
5538: {
5539: liberation(
5540: s_etat_processus,
5541: s_objet_evalue);
5542: }
5543:
5544: (*s_etat_processus)
5545: .instruction_courante =
5546: instruction_courante;
5547: return(d_erreur);
5548: }
5549:
5550: if ((*(*s_etat_processus)
5551: .l_base_pile_systeme)
5552: .type_cloture == 'Q')
5553: {
5554: if (pthread_mutex_unlock(
5555: &mutex_sections_critiques)
5556: != 0)
5557: {
5558: (*s_etat_processus)
5559: .erreur_systeme =
5560: d_es_processus;
5561:
5562: if (presence_egalite ==
5563: d_vrai)
5564: {
5565: liberation(
5566: s_etat_processus,
5567: s_objet_evalue);
5568: }
5569:
5570: (*s_etat_processus)
5571: .instruction_courante =
5572: instruction_courante;
5573: return(d_erreur);
5574: }
5575:
5576: (*s_etat_processus)
5577: .sections_critiques--;
5578: }
5579:
5580: depilement_pile_systeme(
5581: s_etat_processus);
5582:
5583: if ((*s_etat_processus)
5584: .erreur_systeme != d_es)
5585: {
5586: if (presence_egalite ==
5587: d_vrai)
5588: {
5589: liberation(
5590: s_etat_processus,
5591: s_objet_evalue);
5592: }
5593:
5594: (*s_etat_processus)
5595: .instruction_courante =
5596: instruction_courante;
5597: return(d_erreur);
5598: }
5599: }
5600: }
5601: }
5602: }
5603: }
5604:
5605: (*s_etat_processus).instruction_courante =
5606: instruction_courante;
5607: drapeau_then = d_faux;
5608:
5609: do
5610: {
5611: l_registre_atome = l_element_courant;
5612:
5613: if (l_element_courant == NULL)
5614: {
5615: /*
5616: * La fin de l'expression est atteinte,
5617: * le séquenceur reprend la main.
5618: */
5619:
5620: if (presence_egalite == d_vrai)
5621: {
5622: liberation(s_etat_processus,
5623: s_objet_evalue);
5624: }
5625:
5626: (*s_etat_processus)
5627: .mode_execution_programme =
5628: registre_mode_execution_programme;
5629: (*s_etat_processus).instruction_courante =
5630: instruction_courante;
5631: return(d_absence_erreur);
5632: }
5633:
5634: if ((*(*l_element_courant).donnee).type == FCT)
5635: {
5636: (*s_etat_processus)
5637: .instruction_courante =
5638: (*((struct_fonction *)
5639: (*(*l_element_courant).donnee)
5640: .objet)).nom_fonction;
5641: fonction = (*((struct_fonction *)
5642: (*(*l_element_courant).donnee)
5643: .objet)).fonction;
5644: (*s_etat_processus).instruction_courante =
5645: instruction_courante;
5646:
5647: drapeau_then = TEST(instruction_then)
5648: ? d_vrai : d_faux;
5649: }
5650:
5651: l_element_courant = (*l_element_courant)
5652: .suivant;
5653: } while(drapeau_then == d_faux);
5654:
5655: (*s_etat_processus).expression_courante =
5656: l_registre_atome;
5657:
5658: (*(*s_etat_processus).l_base_pile_systeme)
5659: .clause = 'X';
5660: instruction_then(s_etat_processus);
5661:
5662: (*s_etat_processus).exception = d_ep;
5663: (*s_etat_processus).erreur_execution = d_ex;
5664: }
5665: else if ((*s_etat_processus).mode_evaluation_expression
5666: == 'Y')
5667: {
5668: /*
5669: * Reprise sur erreur
5670: */
5671:
5672: while(l_element_courant != NULL)
5673: {
5674: if ((*(*l_element_courant).donnee).type == FCT)
5675: {
5676: (*s_etat_processus).instruction_courante =
5677: (*((struct_fonction *)
5678: (*(*l_element_courant).donnee)
5679: .objet)).nom_fonction;
5680: fonction = (*((struct_fonction *)
5681: (*(*l_element_courant).donnee)
5682: .objet)).fonction;
5683:
5684: if (recherche_variable(s_etat_processus,
5685: (*s_etat_processus)
5686: .instruction_courante) == d_faux)
5687: {
5688: (*s_etat_processus).erreur_systeme
5689: = d_es;
5690:
5691: /*
5692: * Traitement de la pile système par les
5693: * différentes instructions.
5694: */
5695:
5696: if (TEST(instruction_if) ||
5697: TEST(instruction_iferr) ||
5698: TEST(instruction_do) ||
5699: TEST(instruction_while) ||
5700: TEST(instruction_for) ||
5701: TEST(instruction_forall) ||
5702: TEST(instruction_start) ||
5703: TEST(instruction_select) ||
5704: TEST(instruction_case) ||
5705: TEST(instruction_critical) ||
5706: TEST(vers_niveau_superieur))
5707: {
5708: if (TEST(vers_niveau_superieur))
5709: {
5710: analyse(s_etat_processus,
5711: vers_niveau_superieur);
5712:
5713: if ((*s_etat_processus)
5714: .erreur_systeme != d_es)
5715: {
5716: if (presence_egalite ==
5717: d_vrai)
5718: {
5719: liberation(
5720: s_etat_processus,
5721: s_objet_evalue);
5722: }
5723:
5724: (*s_etat_processus)
5725: .instruction_courante =
5726: instruction_courante;
5727: return(d_erreur);
5728: }
5729: }
5730: else if (TEST(instruction_for) ||
5731: TEST(instruction_forall) ||
5732: TEST(instruction_start))
5733: {
5734: empilement_pile_systeme(
5735: s_etat_processus);
5736:
5737: if ((*s_etat_processus)
5738: .erreur_systeme != d_es)
5739: {
5740: if (presence_egalite ==
5741: d_vrai)
5742: {
5743: liberation(
5744: s_etat_processus,
5745: s_objet_evalue);
5746: }
5747:
5748: (*s_etat_processus)
5749: .instruction_courante =
5750: instruction_courante;
5751: return(d_erreur);
5752: }
5753:
5754: (*(*s_etat_processus)
5755: .l_base_pile_systeme)
5756: .type_cloture = 'L';
5757: }
5758: else
5759: {
5760: empilement_pile_systeme(
5761: s_etat_processus);
5762:
5763: if ((*s_etat_processus)
5764: .erreur_systeme != d_es)
5765: {
5766: if (presence_egalite ==
5767: d_vrai)
5768: {
5769: liberation(
5770: s_etat_processus,
5771: s_objet_evalue);
5772: }
5773:
5774: (*s_etat_processus)
5775: .instruction_courante =
5776: instruction_courante;
5777: return(d_erreur);
5778: }
5779: }
5780: }
5781: else if (TEST(instruction_end) ||
5782: TEST(instruction_next) ||
5783: TEST(instruction_step) ||
5784: TEST(vers_niveau_inferieur))
5785: {
5786: if (TEST(vers_niveau_inferieur))
5787: {
5788: analyse(s_etat_processus,
5789: vers_niveau_inferieur);
5790:
5791: if ((*s_etat_processus)
5792: .erreur_systeme != d_es)
5793: {
5794: if (presence_egalite ==
5795: d_vrai)
5796: {
5797: liberation(
5798: s_etat_processus,
5799: s_objet_evalue);
5800: }
5801:
5802: (*s_etat_processus)
5803: .instruction_courante =
5804: instruction_courante;
5805: return(d_erreur);
5806: }
5807: }
5808: else if ((TEST(instruction_next) ||
5809: TEST(instruction_step)) &&
5810: ((*(*s_etat_processus)
5811: .l_base_pile_systeme)
5812: .type_cloture != 'L'))
5813: {
5814: /*
5815: * Libération des compteurs
5816: * de boucle
5817: */
5818:
5819: presence_compteur =
5820: (((*(*s_etat_processus)
5821: .l_base_pile_systeme)
5822: .type_cloture == 'F') ||
5823: ((*(*s_etat_processus)
5824: .l_base_pile_systeme)
5825: .type_cloture == 'A'))
5826: ? d_vrai : d_faux;
5827:
5828: if (((*(*s_etat_processus)
5829: .l_base_pile_systeme)
5830: .type_cloture != 'S') &&
5831: (presence_compteur ==
5832: d_faux))
5833: {
5834: (*s_etat_processus)
5835: .erreur_execution =
5836: d_ex_erreur_traitement_boucle;
5837:
5838: if (presence_egalite ==
5839: d_vrai)
5840: {
5841: liberation(
5842: s_etat_processus,
5843: s_objet_evalue);
5844: }
5845:
5846: (*s_etat_processus)
5847: .instruction_courante =
5848: instruction_courante;
5849: return(d_erreur);
5850: }
5851:
5852: if (presence_compteur == d_vrai)
5853: {
5854: if (recherche_variable(
5855: s_etat_processus,
5856: (*(*s_etat_processus)
5857: .l_base_pile_systeme)
5858: .nom_variable) ==
5859: d_faux)
5860: {
5861: (*s_etat_processus)
5862: .erreur_systeme = d_es;
5863: (*s_etat_processus)
5864: .erreur_execution =
5865: d_ex_erreur_traitement_boucle;
5866:
5867: if (presence_egalite ==
5868: d_vrai)
5869: {
5870: liberation(
5871: s_etat_processus,
5872: s_objet_evalue);
5873: }
5874:
5875: (*s_etat_processus)
5876: .instruction_courante =
5877: instruction_courante;
5878: return(d_erreur);
5879: }
5880:
5881: if ((*(*s_etat_processus)
5882: .pointeur_variable_courante)
5883: .objet == NULL)
5884: {
5885: (*s_etat_processus)
5886: .erreur_systeme = d_es;
5887: (*s_etat_processus)
5888: .erreur_execution =
5889: d_ex_variable_partagee;
5890:
5891: if (presence_egalite ==
5892: d_vrai)
5893: {
5894: liberation(
5895: s_etat_processus,
5896: s_objet_evalue);
5897: }
5898:
5899: (*s_etat_processus)
5900: .instruction_courante =
5901: instruction_courante;
5902: return(d_erreur);
5903: }
5904:
5905: (*s_etat_processus)
5906: .niveau_courant--;
5907:
5908: if (
5909: retrait_variables_par_niveau(
5910: s_etat_processus) == d_erreur)
5911: {
5912: if (presence_egalite ==
5913: d_vrai)
5914: {
5915: liberation(
5916: s_etat_processus,
5917: s_objet_evalue);
5918: }
5919:
5920: (*s_etat_processus)
5921: .instruction_courante =
5922: instruction_courante;
5923: return(d_erreur);
5924: }
5925: }
5926:
5927: depilement_pile_systeme(
5928: s_etat_processus);
5929: }
5930: else
5931: {
5932: // Traitement spécifique pour la
5933: // fin d'une section critique
5934:
5935: if ((*s_etat_processus)
5936: .l_base_pile_systeme ==
5937: NULL)
5938: {
5939: (*s_etat_processus)
5940: .erreur_systeme =
5941: d_es_end_incoherent;
5942:
5943: if (presence_egalite ==
5944: d_vrai)
5945: {
5946: liberation(
5947: s_etat_processus,
5948: s_objet_evalue);
5949: }
5950:
5951: (*s_etat_processus)
5952: .instruction_courante =
5953: instruction_courante;
5954: return(d_erreur);
5955: }
5956:
5957: if ((*(*s_etat_processus)
5958: .l_base_pile_systeme)
5959: .type_cloture == 'Q')
5960: {
5961: if (pthread_mutex_unlock(
5962: &mutex_sections_critiques)
5963: != 0)
5964: {
5965: (*s_etat_processus)
5966: .erreur_systeme =
5967: d_es_processus;
5968:
5969: if (presence_egalite ==
5970: d_vrai)
5971: {
5972: liberation(
5973: s_etat_processus,
5974: s_objet_evalue);
5975: }
5976:
5977: (*s_etat_processus)
5978: .instruction_courante =
5979: instruction_courante;
5980: return(d_erreur);
5981: }
5982:
5983: (*s_etat_processus)
5984: .sections_critiques--;
5985: }
5986:
5987: depilement_pile_systeme(
5988: s_etat_processus);
5989:
5990: if ((*s_etat_processus)
5991: .erreur_systeme != d_es)
5992: {
5993: if (presence_egalite ==
5994: d_vrai)
5995: {
5996: liberation(
5997: s_etat_processus,
5998: s_objet_evalue);
5999: }
6000:
6001: (*s_etat_processus)
6002: .instruction_courante =
6003: instruction_courante;
6004: return(d_erreur);
6005: }
6006: }
6007: }
6008: }
6009: }
6010:
6011: l_element_courant =
6012: (*l_element_courant).suivant;
6013: }
6014:
6015: (*s_etat_processus).mode_execution_programme =
6016: registre_mode_execution_programme;
6017: (*s_etat_processus).instruction_courante =
6018: instruction_courante;
6019:
6020: (*s_etat_processus).exception = d_ep;
6021: (*s_etat_processus).erreur_execution = d_ex;
6022:
6023: erreur_evaluation = d_erreur;
6024: }
6025: else
6026: {
6027: // On ne détruit pas les variables pour les inclure
6028: // dans le fichier rpl-core.
6029:
6030: (*s_etat_processus).gel_liste_variables = d_vrai;
6031:
6032: registre_erreur_execution =
6033: (*s_etat_processus).erreur_execution;
6034: registre_exception =
6035: (*s_etat_processus).exception;
6036: registre_erreur_systeme =
6037: (*s_etat_processus).erreur_systeme;
6038:
6039: (*s_etat_processus).s_objet_errone = s_objet;
6040: (*s_etat_processus).s_objet_erreur =
6041: (*l_element_courant).donnee;
6042:
6043: l_element_courant = (*l_element_courant).suivant;
6044:
6045: while(l_element_courant != NULL)
6046: {
6047: if ((*(*l_element_courant).donnee).type == FCT)
6048: {
6049: (*s_etat_processus).instruction_courante =
6050: (*((struct_fonction *)
6051: (*(*l_element_courant).donnee)
6052: .objet)).nom_fonction;
6053: fonction = (*((struct_fonction *)
6054: (*(*l_element_courant).donnee)
6055: .objet)).fonction;
6056:
6057: if (recherche_variable(s_etat_processus,
6058: (*s_etat_processus)
6059: .instruction_courante) == d_faux)
6060: {
6061: (*s_etat_processus).erreur_systeme
6062: = d_es;
6063:
6064: /*
6065: * Traitement de la pile système par les
6066: * différentes instructions.
6067: */
6068:
6069: if (TEST(instruction_if) ||
6070: TEST(instruction_iferr) ||
6071: TEST(instruction_do) ||
6072: TEST(instruction_while) ||
6073: TEST(instruction_for) ||
6074: TEST(instruction_forall) ||
6075: TEST(instruction_start) ||
6076: TEST(instruction_select) ||
6077: TEST(instruction_case) ||
6078: TEST(instruction_critical) ||
6079: TEST(vers_niveau_superieur))
6080: {
6081: if (TEST(vers_niveau_superieur))
6082: {
6083: analyse(s_etat_processus,
6084: vers_niveau_superieur);
6085:
6086: if ((*s_etat_processus)
6087: .erreur_systeme != d_es)
6088: {
6089: if (presence_egalite ==
6090: d_vrai)
6091: {
6092: liberation(
6093: s_etat_processus,
6094: s_objet_evalue);
6095: }
6096:
6097: (*s_etat_processus)
6098: .instruction_courante =
6099: instruction_courante;
6100: return(d_erreur);
6101: }
6102: }
6103: else if (TEST(instruction_for) ||
6104: TEST(instruction_forall) ||
6105: TEST(instruction_start))
6106: {
6107: empilement_pile_systeme(
6108: s_etat_processus);
6109:
6110: if ((*s_etat_processus)
6111: .erreur_systeme != d_es)
6112: {
6113: if (presence_egalite ==
6114: d_vrai)
6115: {
6116: liberation(
6117: s_etat_processus,
6118: s_objet_evalue);
6119: }
6120:
6121: (*s_etat_processus)
6122: .instruction_courante =
6123: instruction_courante;
6124: return(d_erreur);
6125: }
6126:
6127: (*(*s_etat_processus)
6128: .l_base_pile_systeme)
6129: .type_cloture = 'L';
6130: }
6131: else
6132: {
6133: empilement_pile_systeme(
6134: s_etat_processus);
6135:
6136: if ((*s_etat_processus)
6137: .erreur_systeme != d_es)
6138: {
6139: if (presence_egalite ==
6140: d_vrai)
6141: {
6142: liberation(
6143: s_etat_processus,
6144: s_objet_evalue);
6145: }
6146:
6147: (*s_etat_processus)
6148: .instruction_courante =
6149: instruction_courante;
6150: return(d_erreur);
6151: }
6152: }
6153: }
6154: else if (TEST(instruction_end) ||
6155: TEST(instruction_next) ||
6156: TEST(instruction_step) ||
6157: TEST(vers_niveau_inferieur))
6158: {
6159: if (TEST(vers_niveau_inferieur))
6160: {
6161: analyse(s_etat_processus,
6162: vers_niveau_inferieur);
6163:
6164: if ((*s_etat_processus)
6165: .erreur_systeme != d_es)
6166: {
6167: if (presence_egalite ==
6168: d_vrai)
6169: {
6170: liberation(
6171: s_etat_processus,
6172: s_objet_evalue);
6173: }
6174:
6175: (*s_etat_processus)
6176: .instruction_courante =
6177: instruction_courante;
6178: return(d_erreur);
6179: }
6180: }
6181: else if ((TEST(instruction_next) ||
6182: TEST(instruction_step)) &&
6183: ((*(*s_etat_processus)
6184: .l_base_pile_systeme)
6185: .type_cloture != 'L'))
6186: {
6187: /*
6188: * Libération des compteurs
6189: * de boucle
6190: */
6191:
6192: presence_compteur =
6193: (((*(*s_etat_processus)
6194: .l_base_pile_systeme)
6195: .type_cloture == 'F') ||
6196: ((*(*s_etat_processus)
6197: .l_base_pile_systeme)
6198: .type_cloture == 'A'))
6199: ? d_vrai : d_faux;
6200:
6201: if (((*(*s_etat_processus)
6202: .l_base_pile_systeme)
6203: .type_cloture != 'S') &&
6204: (presence_compteur ==
6205: d_faux))
6206: {
6207: (*s_etat_processus)
6208: .erreur_execution =
6209: d_ex_erreur_traitement_boucle;
6210:
6211: if (presence_egalite ==
6212: d_vrai)
6213: {
6214: liberation(
6215: s_etat_processus,
6216: s_objet_evalue);
6217: }
6218:
6219: (*s_etat_processus)
6220: .instruction_courante =
6221: instruction_courante;
6222: return(d_erreur);
6223: }
6224:
6225: if (presence_compteur == d_vrai)
6226: {
6227: if (recherche_variable(
6228: s_etat_processus,
6229: (*(*s_etat_processus)
6230: .l_base_pile_systeme)
6231: .nom_variable) ==
6232: d_faux)
6233: {
6234: (*s_etat_processus)
6235: .erreur_systeme = d_es;
6236: (*s_etat_processus)
6237: .erreur_execution =
6238: d_ex_erreur_traitement_boucle;
6239:
6240: if (presence_egalite ==
6241: d_vrai)
6242: {
6243: liberation(
6244: s_etat_processus,
6245: s_objet_evalue);
6246: }
6247:
6248: (*s_etat_processus)
6249: .instruction_courante =
6250: instruction_courante;
6251: return(d_erreur);
6252: }
6253:
6254: if ((*(*s_etat_processus)
6255: .pointeur_variable_courante)
6256: .objet == NULL)
6257: {
6258: (*s_etat_processus)
6259: .erreur_systeme = d_es;
6260: (*s_etat_processus)
6261: .erreur_execution =
6262: d_ex_variable_partagee;
6263:
6264: if (presence_egalite ==
6265: d_vrai)
6266: {
6267: liberation(
6268: s_etat_processus,
6269: s_objet_evalue);
6270: }
6271:
6272: (*s_etat_processus)
6273: .instruction_courante =
6274: instruction_courante;
6275: return(d_erreur);
6276: }
6277:
6278: (*s_etat_processus)
6279: .niveau_courant--;
6280:
6281: if (
6282: retrait_variables_par_niveau(
6283: s_etat_processus) == d_erreur)
6284: {
6285: if (presence_egalite ==
6286: d_vrai)
6287: {
6288: liberation(
6289: s_etat_processus,
6290: s_objet_evalue);
6291: }
6292:
6293: (*s_etat_processus)
6294: .instruction_courante =
6295: instruction_courante;
6296: return(d_erreur);
6297: }
6298: }
6299:
6300: depilement_pile_systeme(
6301: s_etat_processus);
6302: }
6303: else
6304: {
6305: // Traitement spécifique pour la
6306: // fin d'une section critique
6307:
6308: if ((*s_etat_processus)
6309: .l_base_pile_systeme ==
6310: NULL)
6311: {
6312: (*s_etat_processus)
6313: .erreur_systeme =
6314: d_es_end_incoherent;
6315:
6316: if (presence_egalite ==
6317: d_vrai)
6318: {
6319: liberation(
6320: s_etat_processus,
6321: s_objet_evalue);
6322: }
6323:
6324: (*s_etat_processus)
6325: .instruction_courante =
6326: instruction_courante;
6327: return(d_erreur);
6328: }
6329:
6330: if ((*(*s_etat_processus)
6331: .l_base_pile_systeme)
6332: .type_cloture == 'Q')
6333: {
6334: if (pthread_mutex_unlock(
6335: &mutex_sections_critiques)
6336: != 0)
6337: {
6338: (*s_etat_processus)
6339: .erreur_systeme =
6340: d_es_processus;
6341:
6342: if (presence_egalite ==
6343: d_vrai)
6344: {
6345: liberation(
6346: s_etat_processus,
6347: s_objet_evalue);
6348: }
6349:
6350: (*s_etat_processus)
6351: .instruction_courante =
6352: instruction_courante;
6353: return(d_erreur);
6354: }
6355:
6356: (*s_etat_processus)
6357: .sections_critiques--;
6358: }
6359:
6360: depilement_pile_systeme(
6361: s_etat_processus);
6362:
6363: if ((*s_etat_processus)
6364: .erreur_systeme != d_es)
6365: {
6366: if (presence_egalite ==
6367: d_vrai)
6368: {
6369: liberation(
6370: s_etat_processus,
6371: s_objet_evalue);
6372: }
6373:
6374: (*s_etat_processus)
6375: .instruction_courante =
6376: instruction_courante;
6377: return(d_erreur);
6378: }
6379: }
6380: }
6381: }
6382: }
6383:
6384: l_element_courant =
6385: (*l_element_courant).suivant;
6386: }
6387:
6388: (*s_etat_processus).mode_execution_programme =
6389: registre_mode_execution_programme;
6390: (*s_etat_processus).instruction_courante =
6391: instruction_courante;
6392: if (presence_egalite == d_vrai)
6393: {
6394: liberation(s_etat_processus, s_objet_evalue);
6395: }
6396:
6397: if ((*s_etat_processus)
6398: .var_volatile_processus_pere == 0)
6399: {
6400: envoi_signal_processus((*s_etat_processus)
6401: .pid_processus_pere, rpl_sigalrm);
6402: }
6403: else
6404: {
6405: (*s_etat_processus).var_volatile_alarme = -1;
6406: }
6407:
6408: (*s_etat_processus).erreur_execution =
6409: registre_erreur_execution;
6410: (*s_etat_processus).erreur_systeme =
6411: registre_erreur_systeme;
6412: (*s_etat_processus).exception =
6413: registre_exception;
6414: return(d_erreur);
6415: }
6416: }
6417: }
6418: else if ((*s_etat_processus).constante_symbolique == 'N')
6419: {
6420: if ((s_objet_elementaire = copie_objet(s_etat_processus,
6421: (*l_element_courant).donnee, 'P')) == NULL)
6422: {
6423: if (presence_egalite == d_vrai)
6424: {
6425: liberation(s_etat_processus, s_objet_evalue);
6426: }
6427:
6428: (*s_etat_processus).erreur_systeme =
6429: d_es_allocation_memoire;
6430: (*s_etat_processus).instruction_courante =
6431: instruction_courante;
6432: return(d_erreur);
6433: }
6434:
6435: presence_fonction = d_faux;
6436: presence_variable_partagee = d_faux;
6437:
6438: if (recherche_variable(s_etat_processus, (*((struct_nom *)
6439: (*s_objet_elementaire).objet)).nom) == d_faux)
6440: {
6441: (*s_etat_processus).erreur_systeme = d_es;
6442: presence_variable = d_faux;
6443:
6444: if ((*s_etat_processus).autorisation_nom_implicite
6445: == 'N')
6446: {
6447: if ((*((struct_nom *) (*s_objet_elementaire).objet))
6448: .symbole == d_faux)
6449: {
6450: if (test_cfsf(s_etat_processus, 31) == d_vrai)
6451: {
6452: if (empilement_pile_last(s_etat_processus,
6453: 0) == d_erreur)
6454: {
6455: return(d_erreur);
6456: }
6457: }
6458:
6459: erreur_evaluation = d_erreur;
6460: (*s_etat_processus).erreur_execution =
6461: d_ex_nom_implicite;
6462:
6463: if (type_evaluation == 'I')
6464: {
6465: (*s_etat_processus)
6466: .derniere_erreur_evaluation =
6467: (*s_etat_processus)
6468: .erreur_execution;
6469: }
6470: }
6471: }
6472: }
6473: else
6474: {
6475: if ((*s_etat_processus).traitement_symbolique == 'N')
6476: {
6477: if ((*(*s_etat_processus)
6478: .pointeur_variable_courante).objet == NULL)
6479: {
6480: // Variable partagée
6481:
6482: presence_variable_partagee = d_faux;
6483:
6484: if (recherche_variable_partagee(
6485: s_etat_processus, (*(*s_etat_processus)
6486: .pointeur_variable_courante).nom,
6487: (*(*s_etat_processus)
6488: .pointeur_variable_courante)
6489: .variable_partagee, 'E') != NULL)
6490: {
6491: presence_variable = d_vrai;
6492: presence_variable_partagee = d_vrai;
6493:
6494: if ((*(*(*s_etat_processus)
6495: .pointeur_variable_partagee_courante
6496: ).objet).type == ADR)
6497: {
6498: presence_fonction = d_vrai;
6499: }
6500:
6501: if ((type_evaluation == 'N') ||
6502: ((*((struct_nom *)
6503: (*(*l_element_courant).donnee)
6504: .objet)).symbole == d_faux))
6505: {
6506: if ((s_copie_variable_partagee =
6507: copie_objet(s_etat_processus,
6508: (*(*s_etat_processus)
6509: .pointeur_variable_partagee_courante
6510: ).objet, 'P')) == NULL)
6511: {
6512: if (pthread_mutex_unlock(
6513: &((*(*s_etat_processus)
6514: .pointeur_variable_partagee_courante
6515: ).mutex)) != 0)
6516: {
6517: (*s_etat_processus)
6518: .erreur_systeme =
6519: d_es_processus;
6520: return(d_erreur);
6521: }
6522: }
6523: }
6524: else
6525: {
6526: s_copie_variable_partagee = NULL;
6527: }
6528:
6529: if (pthread_mutex_unlock(
6530: &((*(*s_etat_processus)
6531: .pointeur_variable_partagee_courante
6532: ).mutex)) != 0)
6533: {
6534: (*s_etat_processus).erreur_systeme =
6535: d_es_processus;
6536: return(d_erreur);
6537: }
6538: }
6539: else
6540: {
6541: (*s_etat_processus).erreur_systeme = d_es;
6542: presence_variable = d_faux;
6543: presence_variable_partagee = d_faux;
6544: }
6545: }
6546: else
6547: {
6548: presence_variable = d_vrai;
6549:
6550: if ((*(*(*s_etat_processus)
6551: .pointeur_variable_courante).objet)
6552: .type == ADR)
6553: {
6554: presence_fonction = d_vrai;
6555: }
6556: }
6557: }
6558: else
6559: {
6560: presence_variable = d_faux;
6561: }
6562: }
6563:
6564: liberation(s_etat_processus, s_objet_elementaire);
6565:
6566: if (presence_fonction == d_vrai)
6567: {
6568: if ((*((struct_nom *) (*(*l_element_courant).donnee)
6569: .objet)).symbole == d_vrai)
6570: {
6571: // L'objet apparaît comme un symbole dans
6572: // l'expression en cours d'évaluation. On se
6573: // contente de l'empiler.
6574:
6575: if ((s_sous_objet = copie_objet(s_etat_processus,
6576: (*l_element_courant).donnee, 'P')) == NULL)
6577: {
6578: (*s_etat_processus).instruction_courante =
6579: instruction_courante;
6580:
6581: (*s_etat_processus).erreur_systeme =
6582: d_es_allocation_memoire;
6583: return(d_erreur);
6584: }
6585:
6586: if (empilement(s_etat_processus,
6587: &((*s_etat_processus).l_base_pile),
6588: s_sous_objet) == d_erreur)
6589: {
6590: (*s_etat_processus).instruction_courante =
6591: instruction_courante;
6592: liberation(s_etat_processus, s_sous_objet);
6593: return(d_erreur);
6594: }
6595: }
6596: else
6597: {
6598: autorisation_empilement_programme =
6599: (*s_etat_processus)
6600: .autorisation_empilement_programme;
6601: registre_position_courante = (*s_etat_processus)
6602: .position_courante;
6603:
6604: empilement_pile_systeme(s_etat_processus);
6605:
6606: if ((*s_etat_processus).erreur_systeme != d_es)
6607: {
6608: if (presence_variable_partagee == d_vrai)
6609: {
6610: liberation(s_etat_processus,
6611: s_copie_variable_partagee);
6612: }
6613:
6614: if (presence_egalite == d_vrai)
6615: {
6616: liberation(s_etat_processus,
6617: s_objet_evalue);
6618: }
6619:
6620: (*s_etat_processus).instruction_courante =
6621: instruction_courante;
6622: return(d_erreur);
6623: }
6624:
6625: (*(*s_etat_processus).l_base_pile_systeme)
6626: .retour_definition = 'Y';
6627: (*(*s_etat_processus).l_base_pile_systeme)
6628: .origine_routine_evaluation = 'Y';
6629:
6630: (*s_etat_processus).mode_execution_programme = 'Y';
6631: (*s_etat_processus)
6632: .autorisation_empilement_programme = 'N';
6633:
6634: (*(*s_etat_processus).l_base_pile_systeme)
6635: .niveau_courant = (*s_etat_processus)
6636: .niveau_courant;
6637:
6638: if (presence_variable_partagee == d_faux)
6639: {
6640: (*s_etat_processus).position_courante =
6641: (*((integer8 *)
6642: ((*(*(*s_etat_processus)
6643: .pointeur_variable_courante)
6644: .objet).objet)));
6645: }
6646: else
6647: {
6648: (*s_etat_processus).position_courante =
6649: (*((integer8 *)
6650: (*s_copie_variable_partagee).objet));
6651: liberation(s_etat_processus,
6652: s_copie_variable_partagee);
6653: }
6654:
6655: if ((*s_etat_processus).profilage == d_vrai)
6656: {
6657: profilage(s_etat_processus,
6658: (*(*s_etat_processus)
6659: .pointeur_variable_courante).nom);
6660:
6661: if ((*s_etat_processus).erreur_systeme != d_es)
6662: {
6663: return(d_erreur);
6664: }
6665: }
6666:
6667: registre_evaluation_forcee =
6668: (*s_etat_processus).evaluation_forcee;
6669:
6670: if (type_evaluation == 'N')
6671: {
6672: (*s_etat_processus).evaluation_forcee = 'Y';
6673: }
6674:
6675: if (sequenceur(s_etat_processus) == d_erreur)
6676: {
6677: (*s_etat_processus).evaluation_forcee =
6678: registre_evaluation_forcee;
6679:
6680: if (presence_egalite == d_vrai)
6681: {
6682: liberation(s_etat_processus,
6683: s_objet_evalue);
6684: }
6685:
6686: depilement_pile_systeme(s_etat_processus);
6687:
6688: (*s_etat_processus).instruction_courante =
6689: instruction_courante;
6690: (*s_etat_processus).mode_execution_programme =
6691: registre_mode_execution_programme;
6692: return(d_erreur);
6693: }
6694:
6695: (*s_etat_processus).evaluation_forcee =
6696: registre_evaluation_forcee;
6697: (*s_etat_processus).instruction_courante =
6698: instruction_courante;
6699: (*s_etat_processus).mode_execution_programme = 'N';
6700:
6701: depilement_pile_systeme(s_etat_processus);
6702:
6703: if ((*s_etat_processus).erreur_systeme != d_es)
6704: {
6705: if (presence_egalite == d_vrai)
6706: {
6707: liberation(s_etat_processus,
6708: s_objet_evalue);
6709: }
6710:
6711: return(d_erreur);
6712: }
6713:
6714: (*s_etat_processus).retour_routine_evaluation = 'N';
6715: (*s_etat_processus).position_courante =
6716: registre_position_courante;
6717: (*s_etat_processus)
6718: .autorisation_empilement_programme =
6719: autorisation_empilement_programme;
6720: }
6721: }
6722: else if (((type_evaluation == 'N') || ((*((struct_nom *)
6723: (*(*l_element_courant).donnee).objet)).symbole ==
6724: d_faux)) && (presence_variable == d_vrai))
6725: {
6726: if (type_evaluation == 'I')
6727: {
6728: if (presence_variable_partagee == d_faux)
6729: {
6730: if ((s_sous_objet =
6731: copie_objet(s_etat_processus,
6732: (*(*s_etat_processus)
6733: .pointeur_variable_courante).objet,
6734: 'P')) == NULL)
6735: {
6736: if (presence_variable_partagee == d_vrai)
6737: {
6738: liberation(s_etat_processus,
6739: s_copie_variable_partagee);
6740: }
6741:
6742: if (presence_egalite == d_vrai)
6743: {
6744: liberation(s_etat_processus,
6745: s_objet_evalue);
6746: }
6747:
6748: (*s_etat_processus).erreur_systeme =
6749: d_es_allocation_memoire;
6750: (*s_etat_processus).instruction_courante =
6751: instruction_courante;
6752: return(d_erreur);
6753: }
6754:
6755: if (empilement(s_etat_processus,
6756: &((*s_etat_processus).l_base_pile),
6757: s_sous_objet) == d_erreur)
6758: {
6759: if (presence_variable_partagee == d_vrai)
6760: {
6761: liberation(s_etat_processus,
6762: s_copie_variable_partagee);
6763: }
6764:
6765: if (presence_egalite == d_vrai)
6766: {
6767: liberation(s_etat_processus,
6768: s_objet_evalue);
6769: }
6770:
6771: return(d_erreur);
6772: }
6773: }
6774: else
6775: {
6776: if (empilement(s_etat_processus,
6777: &((*s_etat_processus).l_base_pile),
6778: s_copie_variable_partagee) == d_erreur)
6779: {
6780: if (presence_variable_partagee == d_vrai)
6781: {
6782: liberation(s_etat_processus,
6783: s_copie_variable_partagee);
6784: }
6785:
6786: if (presence_egalite == d_vrai)
6787: {
6788: liberation(s_etat_processus,
6789: s_objet_evalue);
6790: }
6791:
6792: return(d_erreur);
6793: }
6794: }
6795: }
6796: else
6797: {
6798: registre_evaluation_expression_compilee =
6799: (*s_etat_processus)
6800: .evaluation_expression_compilee;
6801:
6802: if (((*(*s_etat_processus)
6803: .pointeur_variable_courante)
6804: .origine == 'E') && ((*(*s_etat_processus)
6805: .pointeur_variable_courante).niveau == 0))
6806: {
6807: (*s_etat_processus)
6808: .evaluation_expression_compilee = 'Y';
6809: }
6810: else
6811: {
6812: (*s_etat_processus)
6813: .evaluation_expression_compilee = 'N';
6814: }
6815:
6816: if (presence_variable_partagee == d_faux)
6817: {
6818: if ((*s_etat_processus).profilage == d_vrai)
6819: {
6820: profilage(s_etat_processus,
6821: (*(*s_etat_processus)
6822: .pointeur_variable_courante).nom);
6823:
6824: if ((*s_etat_processus).erreur_systeme
6825: != d_es)
6826: {
6827: return(d_erreur);
6828: }
6829: }
6830:
6831: empilement_pile_systeme(s_etat_processus);
6832:
6833: (*(*s_etat_processus).l_base_pile_systeme)
6834: .retour_definition = 'Y';
6835: (*(*s_etat_processus).l_base_pile_systeme)
6836: .niveau_courant = (*s_etat_processus)
6837: .niveau_courant;
6838: (*(*s_etat_processus).l_base_pile_systeme)
6839: .pointeur_objet_retour =
6840: l_element_courant;
6841: (*(*s_etat_processus).l_base_pile_systeme)
6842: .origine_routine_evaluation = 'Y';
6843:
6844: if (evaluation(s_etat_processus,
6845: (*(*s_etat_processus)
6846: .pointeur_variable_courante).objet,
6847: type_evaluation) == d_erreur)
6848: {
6849: depilement_pile_systeme(s_etat_processus);
6850:
6851: if ((*s_etat_processus).profilage == d_vrai)
6852: {
6853: profilage(s_etat_processus, NULL);
6854: }
6855:
6856: (*s_etat_processus)
6857: .evaluation_expression_compilee =
6858: registre_evaluation_expression_compilee;
6859:
6860: if (presence_egalite == d_vrai)
6861: {
6862: liberation(s_etat_processus,
6863: s_objet_evalue);
6864: }
6865:
6866: (*s_etat_processus).instruction_courante =
6867: instruction_courante;
6868: (*s_etat_processus).mode_execution_programme
6869: = registre_mode_execution_programme;
6870: return(d_erreur);
6871: }
6872:
6873: depilement_pile_systeme(s_etat_processus);
6874:
6875: if ((((*s_etat_processus).erreur_execution !=
6876: d_ex) || ((*s_etat_processus)
6877: .erreur_systeme != d_es)) &&
6878: ((*s_etat_processus).arret_si_exception
6879: == d_faux))
6880: {
6881: // Reprise sur erreur.
6882:
6883: //==============================================================================
6884: // Réindentation
6885: //==============================================================================
6886:
6887: drapeau_then = d_faux;
6888:
6889: while(drapeau_then == d_faux)
6890: {
6891: l_registre_atome = l_element_courant;
6892: l_element_courant = (*l_element_courant).suivant;
6893:
6894: if (l_element_courant == NULL)
6895: {
6896: /*
6897: * La fin de l'expression est atteinte,
6898: * le sequenceur reprend la main.
6899: */
6900:
6901: if (presence_egalite == d_vrai)
6902: {
6903: liberation(s_etat_processus, s_objet_evalue);
6904: }
6905:
6906: (*s_etat_processus).mode_execution_programme =
6907: registre_mode_execution_programme;
6908: return(d_absence_erreur);
6909: }
6910:
6911: if ((*(*l_element_courant).donnee).type == FCT)
6912: {
6913: (*s_etat_processus).instruction_courante =
6914: (*((struct_fonction *)
6915: (*(*l_element_courant).donnee)
6916: .objet)).nom_fonction;
6917:
6918: if (recherche_variable(s_etat_processus,
6919: (*s_etat_processus).instruction_courante) == d_faux)
6920: {
6921: (*s_etat_processus).erreur_systeme = d_es;
6922: fonction = (*((struct_fonction *)
6923: (*(*l_element_courant).donnee)
6924: .objet)).fonction;
6925:
6926: /*
6927: * Traitement de la pile système par les
6928: * différentes instructions.
6929: */
6930:
6931: if (TEST(instruction_if) ||
6932: TEST(instruction_iferr) ||
6933: TEST(instruction_do) ||
6934: TEST(instruction_while) ||
6935: TEST(instruction_for) ||
6936: TEST(instruction_forall) ||
6937: TEST(instruction_start) ||
6938: TEST(instruction_select) ||
6939: TEST(instruction_case) ||
6940: TEST(instruction_critical) ||
6941: TEST(vers_niveau_superieur))
6942: {
6943: if (TEST(vers_niveau_superieur))
6944: {
6945: registre_exception = (*s_etat_processus)
6946: .exception;
6947: registre_erreur_execution = (*s_etat_processus)
6948: .erreur_execution;
6949:
6950: analyse(s_etat_processus,
6951: vers_niveau_superieur);
6952:
6953: if ((*s_etat_processus).erreur_systeme != d_es)
6954: {
6955: if (presence_egalite == d_vrai)
6956: {
6957: liberation(s_etat_processus,
6958: s_objet_evalue);
6959: }
6960:
6961: (*s_etat_processus).instruction_courante =
6962: instruction_courante;
6963: return(d_erreur);
6964: }
6965:
6966: (*s_etat_processus).exception
6967: = registre_exception;
6968: (*s_etat_processus).erreur_execution =
6969: registre_erreur_execution;
6970: }
6971: else if (TEST(instruction_for) ||
6972: TEST(instruction_forall) ||
6973: TEST(instruction_start))
6974: {
6975: empilement_pile_systeme(s_etat_processus);
6976:
6977: if ((*s_etat_processus).erreur_systeme != d_es)
6978: {
6979: if (presence_egalite == d_vrai)
6980: {
6981: liberation(s_etat_processus,
6982: s_objet_evalue);
6983: }
6984:
6985: (*s_etat_processus).instruction_courante =
6986: instruction_courante;
6987: return(d_erreur);
6988: }
6989:
6990: (*(*s_etat_processus).l_base_pile_systeme)
6991: .type_cloture = 'L';
6992: }
6993: else
6994: {
6995: empilement_pile_systeme(s_etat_processus);
6996:
6997: if ((*s_etat_processus).erreur_systeme != d_es)
6998: {
6999: if (presence_egalite == d_vrai)
7000: {
7001: liberation(s_etat_processus,
7002: s_objet_evalue);
7003: }
7004:
7005: (*s_etat_processus).instruction_courante =
7006: instruction_courante;
7007: return(d_erreur);
7008: }
7009: }
7010: }
7011: else if (TEST(instruction_end) ||
7012: TEST(instruction_next) ||
7013: TEST(instruction_step) ||
7014: TEST(vers_niveau_inferieur))
7015: {
7016: if (TEST(vers_niveau_inferieur))
7017: {
7018: registre_exception = (*s_etat_processus)
7019: .exception;
7020: registre_erreur_execution = (*s_etat_processus)
7021: .erreur_execution;
7022:
7023: analyse(s_etat_processus,
7024: vers_niveau_inferieur);
7025:
7026: if ((*s_etat_processus).erreur_systeme != d_es)
7027: {
7028: if (presence_egalite == d_vrai)
7029: {
7030: liberation(s_etat_processus,
7031: s_objet_evalue);
7032: }
7033:
7034: (*s_etat_processus).instruction_courante =
7035: instruction_courante;
7036: return(d_erreur);
7037: }
7038:
7039: (*s_etat_processus).exception
7040: = registre_exception;
7041: (*s_etat_processus).erreur_execution =
7042: registre_erreur_execution;
7043: }
7044: else if ((TEST(instruction_next) ||
7045: TEST(instruction_step)) &&
7046: ((*(*s_etat_processus)
7047: .l_base_pile_systeme)
7048: .type_cloture != 'L'))
7049: {
7050: /*
7051: * Libération des compteurs
7052: * de boucle
7053: */
7054:
7055: presence_compteur = (((*(*s_etat_processus)
7056: .l_base_pile_systeme).type_cloture == 'F')
7057: || ((*(*s_etat_processus)
7058: .l_base_pile_systeme).type_cloture == 'A'))
7059: ? d_vrai : d_faux;
7060:
7061: if (((*(*s_etat_processus).l_base_pile_systeme)
7062: .type_cloture != 'S') && (presence_compteur
7063: == d_faux))
7064: {
7065: (*s_etat_processus).erreur_execution =
7066: d_ex_erreur_traitement_boucle;
7067:
7068: if (presence_egalite == d_vrai)
7069: {
7070: liberation(s_etat_processus,
7071: s_objet_evalue);
7072: }
7073:
7074: (*s_etat_processus).instruction_courante =
7075: instruction_courante;
7076: return(d_erreur);
7077: }
7078:
7079: if (presence_compteur == d_vrai)
7080: {
7081: if (recherche_variable(s_etat_processus,
7082: (*(*s_etat_processus)
7083: .l_base_pile_systeme).nom_variable)
7084: == d_faux)
7085: {
7086: (*s_etat_processus).erreur_systeme =
7087: d_es;
7088: (*s_etat_processus).erreur_execution =
7089: d_ex_erreur_traitement_boucle;
7090:
7091: if (presence_egalite == d_vrai)
7092: {
7093: liberation(s_etat_processus,
7094: s_objet_evalue);
7095: }
7096:
7097: (*s_etat_processus).instruction_courante
7098: = instruction_courante;
7099: return(d_erreur);
7100: }
7101:
7102: if ((*(*s_etat_processus)
7103: .pointeur_variable_courante)
7104: .objet == NULL)
7105: {
7106: (*s_etat_processus).erreur_systeme =
7107: d_es;
7108: (*s_etat_processus).erreur_execution =
7109: d_ex_variable_partagee;
7110:
7111: if (presence_egalite == d_vrai)
7112: {
7113: liberation(s_etat_processus,
7114: s_objet_evalue);
7115: }
7116:
7117: (*s_etat_processus).instruction_courante
7118: = instruction_courante;
7119: return(d_erreur);
7120: }
7121:
7122: (*s_etat_processus)
7123: .niveau_courant--;
7124:
7125: if (retrait_variables_par_niveau(
7126: s_etat_processus) == d_erreur)
7127: {
7128: if (presence_egalite == d_vrai)
7129: {
7130: liberation(s_etat_processus,
7131: s_objet_evalue);
7132: }
7133:
7134: (*s_etat_processus).instruction_courante = instruction_courante;
7135: return(d_erreur);
7136: }
7137: }
7138:
7139: depilement_pile_systeme(s_etat_processus);
7140: }
7141: else
7142: {
7143: // Traitement spécifique pour
7144: // la fin d'une section
7145: // critique
7146:
7147: if ((*s_etat_processus).l_base_pile_systeme
7148: == NULL)
7149: {
7150: (*s_etat_processus).erreur_systeme =
7151: d_es_end_incoherent;
7152:
7153: if (presence_egalite == d_vrai)
7154: {
7155: liberation(s_etat_processus,
7156: s_objet_evalue);
7157: }
7158:
7159: (*s_etat_processus).instruction_courante =
7160: instruction_courante;
7161: return(d_erreur);
7162: }
7163:
7164: if ((*(*s_etat_processus).l_base_pile_systeme)
7165: .type_cloture == 'Q')
7166: {
7167: if (pthread_mutex_unlock(
7168: &mutex_sections_critiques) != 0)
7169: {
7170: (*s_etat_processus).erreur_systeme =
7171: d_es_processus;
7172:
7173: liberation(s_etat_processus,
7174: s_objet_evalue);
7175:
7176: (*s_etat_processus).instruction_courante = instruction_courante;
7177: return(d_erreur);
7178: }
7179:
7180: (*s_etat_processus).sections_critiques--;
7181: }
7182:
7183: depilement_pile_systeme(s_etat_processus);
7184:
7185: if ((*s_etat_processus)
7186: .erreur_systeme != d_es)
7187: {
7188: if (presence_egalite == d_vrai)
7189: {
7190: liberation(s_etat_processus,
7191: s_objet_evalue);
7192: }
7193:
7194: (*s_etat_processus).instruction_courante =
7195: instruction_courante;
7196: return(d_erreur);
7197: }
7198: }
7199: }
7200: else if (TEST(instruction_then))
7201: {
7202: if ((*(*s_etat_processus).l_base_pile_systeme)
7203: .clause == 'R')
7204: {
7205: (*(*s_etat_processus).l_base_pile_systeme)
7206: .clause = 'X';
7207: instruction_then(s_etat_processus);
7208: drapeau_then = d_vrai;
7209: }
7210: }
7211: }
7212: }
7213: }
7214:
7215: (*s_etat_processus).expression_courante =
7216: l_element_courant;
7217: (*s_etat_processus).instruction_courante =
7218: instruction_courante;
7219:
7220: (*s_etat_processus).exception = d_ep;
7221: (*s_etat_processus).erreur_execution = d_ex;
7222:
7223: //==============================================================================
7224: // Fin de la réindentation
7225: //==============================================================================
7226: }
7227: }
7228: else
7229: {
7230: if ((*s_etat_processus).profilage == d_vrai)
7231: {
7232: profilage(s_etat_processus,
7233: (*(*s_etat_processus)
7234: .pointeur_variable_courante).nom);
7235:
7236: if ((*s_etat_processus).erreur_systeme
7237: != d_es)
7238: {
7239: return(d_erreur);
7240: }
7241: }
7242:
7243: empilement_pile_systeme(s_etat_processus);
7244: (*(*s_etat_processus).l_base_pile_systeme)
7245: .retour_definition = 'Y';
7246: (*(*s_etat_processus).l_base_pile_systeme)
7247: .niveau_courant = (*s_etat_processus)
7248: .niveau_courant;
7249:
7250: if (evaluation(s_etat_processus,
7251: s_copie_variable_partagee,
7252: type_evaluation) == d_erreur)
7253: {
7254: depilement_pile_systeme(s_etat_processus);
7255:
7256: liberation(s_etat_processus,
7257: s_copie_variable_partagee);
7258:
7259: if ((*s_etat_processus).profilage == d_vrai)
7260: {
7261: profilage(s_etat_processus, NULL);
7262: }
7263:
7264: (*s_etat_processus)
7265: .evaluation_expression_compilee =
7266: registre_evaluation_expression_compilee;
7267:
7268: if (presence_egalite == d_vrai)
7269: {
7270: liberation(s_etat_processus,
7271: s_objet_evalue);
7272: }
7273:
7274: (*s_etat_processus).instruction_courante =
7275: instruction_courante;
7276: (*s_etat_processus).mode_execution_programme
7277: = registre_mode_execution_programme;
7278: return(d_erreur);
7279: }
7280:
7281: depilement_pile_systeme(s_etat_processus);
7282:
7283: liberation(s_etat_processus,
7284: s_copie_variable_partagee);
7285: }
7286:
7287: if ((*s_etat_processus).profilage == d_vrai)
7288: {
7289: profilage(s_etat_processus, NULL);
7290: }
7291:
7292: (*s_etat_processus)
7293: .evaluation_expression_compilee =
7294: registre_evaluation_expression_compilee;
7295: }
7296: }
7297: else
7298: {
7299: if (presence_variable_partagee == d_vrai)
7300: {
7301: liberation(s_etat_processus,
7302: s_copie_variable_partagee);
7303: }
7304:
7305: if ((s_objet_elementaire =
7306: copie_objet(s_etat_processus,
7307: (*l_element_courant).donnee, 'P')) == NULL)
7308: {
7309: if (presence_egalite == d_vrai)
7310: {
7311: liberation(s_etat_processus, s_objet_evalue);
7312: }
7313:
7314: (*s_etat_processus).erreur_systeme =
7315: d_es_allocation_memoire;
7316: (*s_etat_processus).instruction_courante =
7317: instruction_courante;
7318: return(d_erreur);
7319: }
7320:
7321: /*
7322: * Vérification du drapeau symbole pour
7323: * savoir si l'on met dans la pile le nom
7324: * ou le contenu de la variable.
7325: */
7326:
7327: if (((*((struct_nom *) (*s_objet_elementaire).objet))
7328: .symbole == d_faux) && ((*s_etat_processus)
7329: .traitement_symbolique == 'N'))
7330: {
7331: if (recherche_variable(s_etat_processus,
7332: (*((struct_nom *) (*s_objet_elementaire)
7333: .objet)).nom) == d_vrai)
7334: {
7335: if ((*(*s_etat_processus)
7336: .pointeur_variable_courante).objet
7337: == NULL)
7338: {
7339: // Variable partagée
7340:
7341: if (recherche_variable_partagee(
7342: s_etat_processus,
7343: (*(*s_etat_processus)
7344: .pointeur_variable_courante).nom,
7345: (*(*s_etat_processus)
7346: .pointeur_variable_courante)
7347: .variable_partagee, 'E') != NULL)
7348: {
7349: liberation(s_etat_processus,
7350: s_objet_elementaire);
7351:
7352: if ((s_objet_elementaire =
7353: copie_objet(s_etat_processus,
7354: (*(*s_etat_processus)
7355: .pointeur_variable_partagee_courante
7356: ).objet, 'P')) == NULL)
7357: {
7358: if (pthread_mutex_unlock(
7359: &((*(*s_etat_processus)
7360: .pointeur_variable_partagee_courante
7361: ).mutex)) != 0)
7362: {
7363: (*s_etat_processus)
7364: .erreur_systeme =
7365: d_es_processus;
7366: return(d_erreur);
7367: }
7368:
7369: if (presence_egalite == d_vrai)
7370: {
7371: liberation(s_etat_processus,
7372: s_objet_evalue);
7373: }
7374:
7375: (*s_etat_processus).erreur_systeme =
7376: d_es_allocation_memoire;
7377: (*s_etat_processus)
7378: .instruction_courante =
7379: instruction_courante;
7380: return(d_erreur);
7381: }
7382:
7383: if (pthread_mutex_unlock(
7384: &((*(*s_etat_processus)
7385: .pointeur_variable_partagee_courante
7386: ).mutex)) != 0)
7387: {
7388: (*s_etat_processus).erreur_systeme =
7389: d_es_processus;
7390: return(d_erreur);
7391: }
7392: }
7393: }
7394: else
7395: {
7396: // Variable privée
7397:
7398: liberation(s_etat_processus,
7399: s_objet_elementaire);
7400:
7401: if ((s_objet_elementaire =
7402: copie_objet(s_etat_processus,
7403: (*(*s_etat_processus)
7404: .pointeur_variable_courante).objet,
7405: 'P')) == NULL)
7406: {
7407: if (presence_egalite == d_vrai)
7408: {
7409: liberation(s_etat_processus,
7410: s_objet_evalue);
7411: }
7412:
7413: (*s_etat_processus).erreur_systeme =
7414: d_es_allocation_memoire;
7415: (*s_etat_processus)
7416: .instruction_courante =
7417: instruction_courante;
7418: return(d_erreur);
7419: }
7420: }
7421: }
7422: else
7423: {
7424: (*s_etat_processus).erreur_systeme = d_es;
7425:
7426: (*((struct_nom *) (*s_objet_elementaire)
7427: .objet)).symbole = d_vrai;
7428: }
7429: }
7430:
7431: if (empilement(s_etat_processus, &((*s_etat_processus)
7432: .l_base_pile), s_objet_elementaire) == d_erreur)
7433: {
7434: if (presence_egalite == d_vrai)
7435: {
7436: liberation(s_etat_processus, s_objet_evalue);
7437: }
7438:
7439: (*s_etat_processus).instruction_courante =
7440: instruction_courante;
7441: return(d_erreur);
7442: }
7443:
7444: if ((*s_etat_processus).erreur_execution ==
7445: d_ex_variable_non_definie)
7446: {
7447: (*s_etat_processus).erreur_execution = d_ex;
7448: }
7449: }
7450: }
7451: else
7452: {
7453: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
7454: == d_vrai) ? 'E' : 'N';
7455:
7456: if (type_evaluation == 'N')
7457: {
7458: cf(s_etat_processus, 35);
7459: }
7460: else
7461: {
7462: sf(s_etat_processus, 35);
7463: }
7464:
7465: analyse(s_etat_processus, NULL);
7466:
7467: if (registre_type_evaluation == 'E')
7468: {
7469: sf(s_etat_processus, 35);
7470: }
7471: else
7472: {
7473: cf(s_etat_processus, 35);
7474: }
7475:
7476: if (((*s_etat_processus).erreur_systeme != d_es) ||
7477: ((*s_etat_processus).erreur_execution != d_ex) ||
7478: ((*s_etat_processus).exception != d_ep))
7479: {
7480: // Il est anormal de récupérer ici une erreur
7481: // d'exécution puisqu'on empile une constante
7482: // symbolique.
7483:
7484: if (presence_egalite == d_vrai)
7485: {
7486: liberation(s_etat_processus, s_objet_evalue);
7487: }
7488:
7489: (*s_etat_processus).instruction_courante =
7490: instruction_courante;
7491: (*s_etat_processus).mode_execution_programme =
7492: registre_mode_execution_programme;
7493: return(d_erreur);
7494: }
7495: }
7496:
7497: (*s_etat_processus).instruction_courante =
7498: instruction_courante;
7499: (*s_etat_processus).test_instruction = registre_test;
7500: (*s_etat_processus).instruction_valide =
7501: registre_instruction_valide;
7502: }
7503: else
7504: {
7505: if ((s_objet_tampon = copie_objet(s_etat_processus,
7506: (*l_element_courant).donnee, 'P')) == NULL)
7507: {
7508: (*s_etat_processus).erreur_systeme =
7509: d_es_allocation_memoire;
7510: (*s_etat_processus).instruction_courante =
7511: instruction_courante;
7512: return(d_erreur);
7513: }
7514:
7515: if (empilement(s_etat_processus, &((*s_etat_processus)
7516: .l_base_pile), s_objet_tampon) == d_erreur)
7517: {
7518: if (presence_egalite == d_vrai)
7519: {
7520: liberation(s_etat_processus, s_objet_evalue);
7521: }
7522:
7523: (*s_etat_processus).instruction_courante =
7524: instruction_courante;
7525: return(d_erreur);
7526: }
7527: }
7528:
7529: // Traitement de l'instruction EXIT en mode interactif
7530:
7531: if ((*s_etat_processus).traitement_cycle_exit != 'N')
7532: {
7533: registre_expression_courante =
7534: (*s_etat_processus).expression_courante;
7535: (*s_etat_processus).expression_courante =
7536: l_element_courant;
7537:
7538: switch((*s_etat_processus).traitement_cycle_exit)
7539: {
7540: case 'C' :
7541: {
7542: instruction_cycle(s_etat_processus);
7543: break;
7544: }
7545:
7546: case 'E' :
7547: {
7548: instruction_exit(s_etat_processus);
7549: break;
7550: }
7551: }
7552:
7553: l_element_courant = (*s_etat_processus).expression_courante;
7554: (*s_etat_processus).expression_courante =
7555: registre_expression_courante;
7556: }
7557:
7558: if (l_element_courant != NULL)
7559: {
7560: l_element_courant = (*l_element_courant).suivant;
7561: }
7562: else
7563: {
7564: (*s_etat_processus).mode_execution_programme = 'Y';
7565:
7566: if ((*s_etat_processus).niveau_courant == 1)
7567: {
7568: (*s_etat_processus).debug_programme = d_faux;
7569: (*s_etat_processus).execution_pas_suivant = d_vrai;
7570: }
7571: }
7572:
7573: }
7574:
7575: if (niveau_initial < (*s_etat_processus).niveau_courant)
7576: {
7577: /*
7578: * Retrait des variables dans le cas où l'évaluation de
7579: * l'expression a été interrompue
7580: */
7581:
7582: (*s_etat_processus).niveau_courant = niveau_initial;
7583:
7584: if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
7585: {
7586: if (presence_egalite == d_vrai)
7587: {
7588: liberation(s_etat_processus, s_objet_evalue);
7589: }
7590:
7591: (*s_etat_processus).instruction_courante =
7592: instruction_courante;
7593: (*s_etat_processus).mode_execution_programme =
7594: registre_mode_execution_programme;
7595: return(d_erreur);
7596: }
7597: }
7598:
7599: /*
7600: * Retrait des variables statiques créées dans l'expression
7601: */
7602:
7603: if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
7604: {
7605: if (presence_egalite == d_vrai)
7606: {
7607: liberation(s_etat_processus, s_objet_evalue);
7608: }
7609:
7610: (*s_etat_processus).instruction_courante =
7611: instruction_courante;
7612: (*s_etat_processus).mode_execution_programme =
7613: registre_mode_execution_programme;
7614: return(d_erreur);
7615: }
7616:
7617: /*
7618: * Retrait des variables partagées créées dans l'expression
7619: */
7620:
7621: if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
7622: {
7623: if (presence_egalite == d_vrai)
7624: {
7625: liberation(s_etat_processus, s_objet_evalue);
7626: }
7627:
7628: (*s_etat_processus).instruction_courante =
7629: instruction_courante;
7630: (*s_etat_processus).mode_execution_programme =
7631: registre_mode_execution_programme;
7632: return(d_erreur);
7633: }
7634:
7635: if ((*s_etat_processus).var_volatile_requete_arret != 0)
7636: {
7637: // Restauration de la pile système
7638:
7639: while(pile_systeme_originelle !=
7640: (*s_etat_processus).l_base_pile_systeme)
7641: {
7642: depilement_pile_systeme(s_etat_processus);
7643: }
7644: }
7645:
7646: if (presence_egalite == d_vrai)
7647: {
7648: // Ajout du membre évalué lors de la première passe
7649:
7650: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
7651: s_objet_evalue) == d_erreur)
7652: {
7653: (*s_etat_processus).instruction_courante =
7654: instruction_courante;
7655: return(d_erreur);
7656: }
7657:
7658: instruction_swap(s_etat_processus);
7659:
7660: if ((*s_etat_processus).erreur_execution != d_ex)
7661: {
7662: (*s_etat_processus).mode_execution_programme =
7663: registre_mode_execution_programme;
7664: (*s_etat_processus).autorisation_empilement_programme =
7665: autorisation_empilement_programme;
7666: (*s_etat_processus).instruction_courante = instruction_courante;
7667: return(d_erreur);
7668: }
7669:
7670: instruction_egalite(s_etat_processus);
7671:
7672: if ((*s_etat_processus).erreur_execution != d_ex)
7673: {
7674: (*s_etat_processus).mode_execution_programme =
7675: registre_mode_execution_programme;
7676: (*s_etat_processus).autorisation_empilement_programme =
7677: autorisation_empilement_programme;
7678: (*s_etat_processus).instruction_courante = instruction_courante;
7679: return(d_erreur);
7680: }
7681: }
7682:
7683: (*s_etat_processus).autorisation_empilement_programme =
7684: autorisation_empilement_programme;
7685: (*s_etat_processus).instruction_courante = instruction_courante;
7686: }
7687: else if ((*s_objet).type == FCT)
7688: {
7689: (*s_etat_processus).instruction_courante =
7690: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
7691:
7692: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
7693: ? 'E' : 'N';
7694: cf(s_etat_processus, 35);
7695:
7696: analyse(s_etat_processus, (*((struct_fonction *)
7697: (*s_objet).objet)).fonction);
7698: (*s_etat_processus).instruction_courante = instruction_courante;
7699:
7700: if (registre_type_evaluation == 'E')
7701: {
7702: sf(s_etat_processus, 35);
7703: }
7704: else
7705: {
7706: cf(s_etat_processus, 35);
7707: }
7708:
7709: if (((*s_etat_processus).erreur_systeme != d_es) ||
7710: ((*s_etat_processus).erreur_execution != d_ex) ||
7711: ((*s_etat_processus).exception != d_ep))
7712: {
7713: (*s_etat_processus).mode_execution_programme =
7714: registre_mode_execution_programme;
7715: return(d_erreur);
7716: }
7717: }
7718: else
7719: {
7720: (*s_etat_processus).instruction_courante = instruction_courante;
7721:
7722: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
7723: == NULL)
7724: {
7725: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
7726: return(d_erreur);
7727: }
7728:
7729: if (empilement(s_etat_processus, &((*s_etat_processus)
7730: .l_base_pile), s_objet_tampon) == d_erreur)
7731: {
7732: return(d_erreur);
7733: }
7734: }
7735:
7736: (*s_etat_processus).mode_execution_programme =
7737: registre_mode_execution_programme;
7738:
7739: return((erreur_evaluation == d_absence_erreur)
7740: ? d_absence_erreur : d_erreur);
7741: }
7742:
7743: // vim: ts=4