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