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