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