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