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