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