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