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