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