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