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