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