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