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