![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to evaluation.c CVS log | Up to [local] / rpl / src |
Première série de patches pour compiler avec l'option -Wconversion.
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: integer8 k;
52: integer8 l;
53: integer8 niveau_initial;
54: integer8 nombre_termes;
55: integer8 registre_hauteur_pile_operationnelle;
56: integer8 registre_position_courante;
57:
58:
59: logical1 drapeau_then;
60: logical1 erreur_evaluation;
61: logical1 presence_compteur;
62: logical1 presence_egalite;
63: logical1 presence_fonction;
64: logical1 presence_variable;
65: logical1 presence_variable_partagee;
66:
67: struct_liste_chainee *l_element_courant;
68: struct_liste_chainee *l_element_egalite;
69: struct_liste_chainee *l_element_fonction;
70: struct_liste_chainee *l_liste1;
71: struct_liste_chainee *l_liste2;
72: struct_liste_chainee *l_registre_atome;
73: struct_liste_chainee *l_registre_pile_operationnelle;
74: struct_liste_chainee *l_sous_element_courant;
75: struct_liste_chainee *registre_expression_courante;
76:
77: struct_liste_pile_systeme *pile_systeme_originelle;
78:
79: struct_objet *s_objet_elementaire;
80: struct_objet *s_objet_evalue;
81: struct_objet *s_objet_indice_i;
82: struct_objet *s_objet_indice_j;
83: struct_objet *s_objet_tampon;
84: struct_objet *s_sous_objet;
85: struct_objet *s_copie_variable_partagee;
86:
87: unsigned char autorisation_empilement_programme;
88: unsigned char *instruction_courante;
89: unsigned char *message;
90: unsigned char registre_evaluation_expression_compilee;
91: unsigned char registre_evaluation_forcee;
92: unsigned char registre_instruction_valide;
93: unsigned char registre_mode_execution_programme;
94: unsigned char registre_retour_definition;
95: unsigned char registre_test;
96: unsigned char registre_test_2;
97: unsigned char registre_type_evaluation;
98:
99: int registre_erreur_execution;
100: int registre_erreur_systeme;
101: int registre_exception;
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: (*((integer8 *) ((*(*(*s_etat_processus)
295: .pointeur_variable_courante).objet).objet)));
296: }
297: else
298: {
299: (*s_etat_processus).position_courante =
300: (*((integer8 *) (*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: (*((integer8 *) ((*(*(*s_etat_processus)
3412: .pointeur_variable_courante).objet).objet)));
3413:
3414: if ((*s_etat_processus).profilage == d_vrai)
3415: {
3416: profilage(s_etat_processus,
3417: (*(*s_etat_processus)
3418: .pointeur_variable_courante).nom);
3419:
3420: if ((*s_etat_processus).erreur_systeme != d_es)
3421: {
3422: if (presence_variable_partagee == d_vrai)
3423: {
3424: (*(*s_etat_processus)
3425: .pointeur_variable_courante).objet =
3426: NULL;
3427:
3428: if (pthread_mutex_unlock(
3429: &((*(*s_etat_processus)
3430: .pointeur_variable_partagee_courante
3431: ).mutex)) != 0)
3432: {
3433: (*s_etat_processus).erreur_systeme =
3434: d_es_processus;
3435: }
3436: }
3437:
3438: return(d_erreur);
3439: }
3440: }
3441:
3442: registre_evaluation_forcee =
3443: (*s_etat_processus).evaluation_forcee;
3444:
3445: if (type_evaluation == 'N')
3446: {
3447: (*s_etat_processus).evaluation_forcee = 'Y';
3448: }
3449:
3450: if (sequenceur(s_etat_processus) == d_erreur)
3451: {
3452: (*s_etat_processus).evaluation_forcee =
3453: registre_evaluation_forcee;
3454:
3455: if (presence_variable_partagee == d_vrai)
3456: {
3457: (*(*s_etat_processus)
3458: .pointeur_variable_courante).objet =
3459: NULL;
3460:
3461: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3462: .pointeur_variable_partagee_courante)
3463: .mutex)) != 0)
3464: {
3465: (*s_etat_processus).erreur_systeme =
3466: d_es_processus;
3467: }
3468: }
3469:
3470: if (presence_egalite == d_vrai)
3471: {
3472: liberation(s_etat_processus, s_objet_evalue);
3473: }
3474:
3475: depilement_pile_systeme(s_etat_processus);
3476:
3477: (*s_etat_processus).instruction_courante =
3478: instruction_courante;
3479: (*s_etat_processus).mode_execution_programme =
3480: registre_mode_execution_programme;
3481: return(d_erreur);
3482: }
3483:
3484: (*s_etat_processus).evaluation_forcee =
3485: registre_evaluation_forcee;
3486: (*s_etat_processus).instruction_courante =
3487: instruction_courante;
3488: (*s_etat_processus).mode_execution_programme = 'N';
3489:
3490: depilement_pile_systeme(s_etat_processus);
3491:
3492: if ((*s_etat_processus).erreur_systeme != d_es)
3493: {
3494: if (presence_variable_partagee == d_vrai)
3495: {
3496: (*(*s_etat_processus)
3497: .pointeur_variable_courante).objet =
3498: NULL;
3499:
3500: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3501: .pointeur_variable_partagee_courante)
3502: .mutex)) != 0)
3503: {
3504: (*s_etat_processus).erreur_systeme =
3505: d_es_processus;
3506: }
3507: }
3508:
3509: if (presence_egalite == d_vrai)
3510: {
3511: liberation(s_etat_processus, s_objet_evalue);
3512: }
3513:
3514: return(d_erreur);
3515: }
3516:
3517: (*s_etat_processus).retour_routine_evaluation = 'N';
3518: (*s_etat_processus).position_courante =
3519: registre_position_courante;
3520: (*s_etat_processus).autorisation_empilement_programme =
3521: autorisation_empilement_programme;
3522:
3523: free(s_objet_elementaire);
3524:
3525: if (depilement(s_etat_processus, &((*s_etat_processus)
3526: .l_base_pile), &s_objet_elementaire)
3527: == d_erreur)
3528: {
3529: if (presence_variable_partagee == d_vrai)
3530: {
3531: (*(*s_etat_processus)
3532: .pointeur_variable_courante).objet =
3533: NULL;
3534:
3535: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3536: .pointeur_variable_partagee_courante)
3537: .mutex)) != 0)
3538: {
3539: (*s_etat_processus).erreur_systeme =
3540: d_es_processus;
3541: }
3542: }
3543:
3544: if (presence_egalite == d_vrai)
3545: {
3546: liberation(s_etat_processus, s_objet_evalue);
3547: }
3548:
3549: (*s_etat_processus).erreur_execution =
3550: d_ex_manque_argument;
3551: (*s_etat_processus).instruction_courante =
3552: instruction_courante;
3553: (*s_etat_processus).mode_execution_programme =
3554: registre_mode_execution_programme;
3555: return(d_erreur);
3556: }
3557: }
3558: else
3559: {
3560: if (presence_variable_partagee == d_vrai)
3561: {
3562: (*(*s_etat_processus)
3563: .pointeur_variable_courante).objet =
3564: NULL;
3565:
3566: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3567: .pointeur_variable_partagee_courante)
3568: .mutex)) != 0)
3569: {
3570: (*s_etat_processus).erreur_systeme =
3571: d_es_processus;
3572: }
3573: }
3574:
3575: if (presence_egalite == d_vrai)
3576: {
3577: liberation(s_etat_processus, s_objet_evalue);
3578: }
3579:
3580: (*s_etat_processus).erreur_execution =
3581: d_ex_element_inexistant;
3582: (*s_etat_processus).instruction_courante =
3583: instruction_courante;
3584: (*s_etat_processus).mode_execution_programme =
3585: registre_mode_execution_programme;
3586:
3587: return(d_erreur);
3588: }
3589:
3590: if (empilement(s_etat_processus, &((*s_etat_processus)
3591: .l_base_pile), s_objet_elementaire) == d_erreur)
3592: {
3593: if (presence_variable_partagee == d_vrai)
3594: {
3595: (*(*s_etat_processus)
3596: .pointeur_variable_courante).objet =
3597: NULL;
3598:
3599: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3600: .pointeur_variable_partagee_courante)
3601: .mutex)) != 0)
3602: {
3603: (*s_etat_processus).erreur_systeme =
3604: d_es_processus;
3605: }
3606: }
3607:
3608: if (presence_egalite == d_vrai)
3609: {
3610: liberation(s_etat_processus, s_objet_evalue);
3611: }
3612:
3613: (*s_etat_processus).instruction_courante =
3614: instruction_courante;
3615: return(d_erreur);
3616: }
3617:
3618: if (presence_variable_partagee == d_vrai)
3619: {
3620: (*(*s_etat_processus)
3621: .pointeur_variable_courante).objet = NULL;
3622:
3623: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3624: .pointeur_variable_partagee_courante).mutex))
3625: != 0)
3626: {
3627: (*s_etat_processus).erreur_systeme =
3628: d_es_processus;
3629: }
3630: }
3631: }
3632: }
3633: else if (((*(*l_element_courant).donnee).type == ALG)
3634: || ((*(*l_element_courant).donnee).type == RPN))
3635: {
3636: if (type_evaluation == 'I')
3637: {
3638: if ((s_objet_elementaire = copie_objet(s_etat_processus,
3639: (*l_element_courant).donnee, 'P')) == NULL)
3640: {
3641: if (presence_egalite == d_vrai)
3642: {
3643: liberation(s_etat_processus, s_objet_evalue);
3644: }
3645:
3646: (*s_etat_processus).erreur_systeme =
3647: d_es_allocation_memoire;
3648: (*s_etat_processus).instruction_courante =
3649: instruction_courante;
3650: return(d_erreur);
3651: }
3652:
3653: if (empilement(s_etat_processus, &((*s_etat_processus)
3654: .l_base_pile), s_objet_elementaire)
3655: == d_erreur)
3656: {
3657: if (presence_egalite == d_vrai)
3658: {
3659: liberation(s_etat_processus, s_objet_evalue);
3660: }
3661:
3662: (*s_etat_processus).instruction_courante =
3663: instruction_courante;
3664: return(d_erreur);
3665: }
3666: }
3667: else
3668: {
3669: if ((*s_etat_processus).autorisation_empilement_programme
3670: == 'N')
3671: {
3672: registre_evaluation_expression_compilee =
3673: (*s_etat_processus)
3674: .evaluation_expression_compilee;
3675:
3676: (*s_etat_processus).evaluation_expression_compilee
3677: = 'N';
3678:
3679: if (evaluation(s_etat_processus, (*l_element_courant)
3680: .donnee, type_evaluation) == d_erreur)
3681: {
3682: (*s_etat_processus).evaluation_expression_compilee
3683: = registre_evaluation_expression_compilee;
3684:
3685: if (presence_egalite == d_vrai)
3686: {
3687: liberation(s_etat_processus, s_objet_evalue);
3688: }
3689:
3690: (*s_etat_processus).instruction_courante =
3691: instruction_courante;
3692: (*s_etat_processus).mode_execution_programme =
3693: registre_mode_execution_programme;
3694: return(d_erreur);
3695: }
3696:
3697: (*s_etat_processus).evaluation_expression_compilee
3698: = registre_evaluation_expression_compilee;
3699: }
3700: else
3701: {
3702: if ((s_objet_elementaire =
3703: copie_objet(s_etat_processus,
3704: (*l_element_courant).donnee, 'P')) == NULL)
3705: {
3706: if (presence_egalite == d_vrai)
3707: {
3708: liberation(s_etat_processus, s_objet_evalue);
3709: }
3710:
3711: (*s_etat_processus).erreur_systeme =
3712: d_es_allocation_memoire;
3713: (*s_etat_processus).instruction_courante =
3714: instruction_courante;
3715: return(d_erreur);
3716: }
3717:
3718: if (empilement(s_etat_processus, &((*s_etat_processus)
3719: .l_base_pile), s_objet_elementaire)
3720: == d_erreur)
3721: {
3722: if (presence_egalite == d_vrai)
3723: {
3724: liberation(s_etat_processus, s_objet_evalue);
3725: }
3726:
3727: (*s_etat_processus).instruction_courante =
3728: instruction_courante;
3729: return(d_erreur);
3730: }
3731: }
3732: }
3733: }
3734: else if ((*(*l_element_courant).donnee).type == NOM)
3735: {
3736: registre_instruction_valide = (*s_etat_processus)
3737: .instruction_valide;
3738: registre_test = (*s_etat_processus).test_instruction;
3739: (*s_etat_processus).test_instruction = 'Y';
3740: (*s_etat_processus).instruction_courante = (*((struct_nom *)
3741: (*(*l_element_courant).donnee).objet)).nom;
3742:
3743: analyse(s_etat_processus, NULL);
3744:
3745: (*s_etat_processus).test_instruction = 'N';
3746:
3747: if ((*s_etat_processus).instruction_valide == 'Y')
3748: {
3749: registre_test_2 = (*s_etat_processus).test_instruction;
3750: (*s_etat_processus).test_instruction = 'N';
3751:
3752: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
3753: == d_vrai) ? 'E' : 'N';
3754:
3755: if (type_evaluation == 'N')
3756: {
3757: cf(s_etat_processus, 35);
3758: }
3759: else
3760: {
3761: sf(s_etat_processus, 35);
3762: }
3763:
3764: analyse(s_etat_processus, NULL);
3765:
3766: if (registre_type_evaluation == 'E')
3767: {
3768: sf(s_etat_processus, 35);
3769: }
3770: else
3771: {
3772: cf(s_etat_processus, 35);
3773: }
3774:
3775: (*s_etat_processus).test_instruction = registre_test_2;
3776:
3777: if ((*s_etat_processus).erreur_systeme != d_es)
3778: {
3779: if (presence_egalite == d_vrai)
3780: {
3781: liberation(s_etat_processus, s_objet_evalue);
3782: }
3783:
3784: if ((*s_etat_processus).var_volatile_processus_pere
3785: == 0)
3786: {
3787: envoi_signal_processus((*s_etat_processus)
3788: .pid_processus_pere, rpl_sigalrm);
3789: }
3790: else
3791: {
3792: (*s_etat_processus).var_volatile_alarme = -1;
3793: }
3794:
3795: (*s_etat_processus).instruction_courante =
3796: instruction_courante;
3797: return(d_erreur);
3798: }
3799: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3800: ((*s_etat_processus).exception != d_ep))
3801: {
3802: if ((*s_etat_processus).arret_si_exception == d_faux)
3803: {
3804: /*
3805: * Reprise sur erreur
3806: */
3807:
3808: if ((message = messages(s_etat_processus)) == NULL)
3809: {
3810: if (presence_egalite == d_vrai)
3811: {
3812: liberation(s_etat_processus,
3813: s_objet_evalue);
3814: }
3815:
3816: (*s_etat_processus).instruction_courante =
3817: instruction_courante;
3818: return(d_erreur);
3819: }
3820:
3821: free(message);
3822:
3823: while((*(*s_etat_processus).l_base_pile_systeme)
3824: .clause != 'R')
3825: {
3826: l_registre_atome = l_element_courant;
3827: l_element_courant =
3828: (*l_element_courant).suivant;
3829:
3830: if (l_element_courant == NULL)
3831: {
3832: /*
3833: * La fin de l'expression est atteinte,
3834: * le sequenceur reprend la main.
3835: */
3836:
3837: if (presence_egalite == d_vrai)
3838: {
3839: liberation(s_etat_processus,
3840: s_objet_evalue);
3841: }
3842:
3843: (*s_etat_processus)
3844: .mode_execution_programme =
3845: registre_mode_execution_programme;
3846: return(d_absence_erreur);
3847: }
3848:
3849: if ((*(*l_element_courant).donnee).type == FCT)
3850: {
3851: (*s_etat_processus).instruction_courante =
3852: (*((struct_fonction *)
3853: (*(*l_element_courant).donnee)
3854: .objet)).nom_fonction;
3855:
3856: if (recherche_variable(s_etat_processus,
3857: (*s_etat_processus)
3858: .instruction_courante) == d_faux)
3859: {
3860: (*s_etat_processus).erreur_systeme
3861: = d_es;
3862: fonction = (*((struct_fonction *)
3863: (*(*l_element_courant).donnee)
3864: .objet)).fonction;
3865:
3866: /*
3867: * Traitement de la pile système par les
3868: * différentes instructions.
3869: */
3870:
3871: if (TEST(instruction_if) ||
3872: TEST(instruction_iferr) ||
3873: TEST(instruction_do) ||
3874: TEST(instruction_while) ||
3875: TEST(instruction_for) ||
3876: TEST(instruction_forall) ||
3877: TEST(instruction_start) ||
3878: TEST(instruction_select) ||
3879: TEST(instruction_case) ||
3880: TEST(instruction_critical) ||
3881: TEST(vers_niveau_superieur))
3882: {
3883: if (TEST(vers_niveau_superieur))
3884: {
3885: registre_exception =
3886: (*s_etat_processus)
3887: .exception;
3888: registre_erreur_execution =
3889: (*s_etat_processus)
3890: .erreur_execution;
3891:
3892: analyse(s_etat_processus,
3893: vers_niveau_superieur);
3894:
3895: if ((*s_etat_processus)
3896: .erreur_systeme != d_es)
3897: {
3898: if (presence_egalite ==
3899: d_vrai)
3900: {
3901: liberation(
3902: s_etat_processus,
3903: s_objet_evalue);
3904: }
3905:
3906: (*s_etat_processus)
3907: .instruction_courante =
3908: instruction_courante;
3909: return(d_erreur);
3910: }
3911:
3912: (*s_etat_processus).exception
3913: = registre_exception;
3914: (*s_etat_processus)
3915: .erreur_execution =
3916: registre_erreur_execution;
3917: }
3918: else if (TEST(instruction_for) ||
3919: TEST(instruction_forall) ||
3920: TEST(instruction_start))
3921: {
3922: empilement_pile_systeme(
3923: s_etat_processus);
3924:
3925: if ((*s_etat_processus)
3926: .erreur_systeme != d_es)
3927: {
3928: if (presence_egalite ==
3929: d_vrai)
3930: {
3931: liberation(
3932: s_etat_processus,
3933: s_objet_evalue);
3934: }
3935:
3936: (*s_etat_processus)
3937: .instruction_courante =
3938: instruction_courante;
3939: return(d_erreur);
3940: }
3941:
3942: (*(*s_etat_processus)
3943: .l_base_pile_systeme)
3944: .type_cloture = 'L';
3945: }
3946: else
3947: {
3948: empilement_pile_systeme(
3949: s_etat_processus);
3950:
3951: if ((*s_etat_processus)
3952: .erreur_systeme != d_es)
3953: {
3954: if (presence_egalite ==
3955: d_vrai)
3956: {
3957: liberation(
3958: s_etat_processus,
3959: s_objet_evalue);
3960: }
3961:
3962: (*s_etat_processus)
3963: .instruction_courante =
3964: instruction_courante;
3965: return(d_erreur);
3966: }
3967: }
3968: }
3969: else if (TEST(instruction_end) ||
3970: TEST(instruction_next) ||
3971: TEST(instruction_step) ||
3972: TEST(vers_niveau_inferieur))
3973: {
3974: if (TEST(vers_niveau_inferieur))
3975: {
3976: registre_exception =
3977: (*s_etat_processus)
3978: .exception;
3979: registre_erreur_execution =
3980: (*s_etat_processus)
3981: .erreur_execution;
3982:
3983: analyse(s_etat_processus,
3984: vers_niveau_inferieur);
3985:
3986: if ((*s_etat_processus)
3987: .erreur_systeme != d_es)
3988: {
3989: if (presence_egalite ==
3990: d_vrai)
3991: {
3992: liberation(
3993: s_etat_processus,
3994: s_objet_evalue);
3995: }
3996:
3997: (*s_etat_processus)
3998: .instruction_courante =
3999: instruction_courante;
4000: return(d_erreur);
4001: }
4002:
4003: (*s_etat_processus).exception
4004: = registre_exception;
4005: (*s_etat_processus)
4006: .erreur_execution =
4007: registre_erreur_execution;
4008: }
4009: else if ((TEST(instruction_next) ||
4010: TEST(instruction_step)) &&
4011: ((*(*s_etat_processus)
4012: .l_base_pile_systeme)
4013: .type_cloture != 'L'))
4014: {
4015: /*
4016: * Libération des compteurs
4017: * de boucle
4018: */
4019:
4020: presence_compteur =
4021: (((*(*s_etat_processus)
4022: .l_base_pile_systeme)
4023: .type_cloture == 'F') ||
4024: ((*(*s_etat_processus)
4025: .l_base_pile_systeme)
4026: .type_cloture == 'A'))
4027: ? d_vrai : d_faux;
4028:
4029: if (((*(*s_etat_processus)
4030: .l_base_pile_systeme)
4031: .type_cloture != 'S') &&
4032: (presence_compteur ==
4033: d_faux))
4034: {
4035: (*s_etat_processus)
4036: .erreur_execution =
4037: d_ex_erreur_traitement_boucle;
4038:
4039: if (presence_egalite ==
4040: d_vrai)
4041: {
4042: liberation(
4043: s_etat_processus,
4044: s_objet_evalue);
4045: }
4046:
4047: (*s_etat_processus)
4048: .instruction_courante =
4049: instruction_courante;
4050: return(d_erreur);
4051: }
4052:
4053: if (presence_compteur == d_vrai)
4054: {
4055: if (recherche_variable(
4056: s_etat_processus,
4057: (*(*s_etat_processus)
4058: .l_base_pile_systeme)
4059: .nom_variable) ==
4060: d_faux)
4061: {
4062: (*s_etat_processus)
4063: .erreur_systeme = d_es;
4064: (*s_etat_processus)
4065: .erreur_execution =
4066: d_ex_erreur_traitement_boucle;
4067:
4068: if (presence_egalite ==
4069: d_vrai)
4070: {
4071: liberation(
4072: s_etat_processus,
4073: s_objet_evalue);
4074: }
4075:
4076: (*s_etat_processus)
4077: .instruction_courante =
4078: instruction_courante;
4079: return(d_erreur);
4080: }
4081:
4082: if ((*(*s_etat_processus)
4083: .pointeur_variable_courante)
4084: .objet == NULL)
4085: {
4086: (*s_etat_processus)
4087: .erreur_systeme = d_es;
4088: (*s_etat_processus)
4089: .erreur_execution =
4090: d_ex_variable_partagee;
4091:
4092: if (presence_egalite ==
4093: d_vrai)
4094: {
4095: liberation(
4096: s_etat_processus,
4097: s_objet_evalue);
4098: }
4099:
4100: (*s_etat_processus)
4101: .instruction_courante =
4102: instruction_courante;
4103: return(d_erreur);
4104: }
4105:
4106: (*s_etat_processus)
4107: .niveau_courant--;
4108:
4109: if (
4110: retrait_variables_par_niveau(
4111: s_etat_processus) == d_erreur)
4112: {
4113: if (presence_egalite ==
4114: d_vrai)
4115: {
4116: liberation(
4117: s_etat_processus,
4118: s_objet_evalue);
4119: }
4120:
4121: (*s_etat_processus)
4122: .instruction_courante =
4123: instruction_courante;
4124: return(d_erreur);
4125: }
4126: }
4127:
4128: depilement_pile_systeme(
4129: s_etat_processus);
4130: }
4131: else
4132: {
4133: // Traitement spécifique pour la
4134: // fin d'une section critique
4135:
4136: if ((*s_etat_processus)
4137: .l_base_pile_systeme ==
4138: NULL)
4139: {
4140: (*s_etat_processus)
4141: .erreur_systeme =
4142: d_es_end_incoherent;
4143:
4144: if (presence_egalite ==
4145: d_vrai)
4146: {
4147: liberation(
4148: s_etat_processus,
4149: s_objet_evalue);
4150: }
4151:
4152: (*s_etat_processus)
4153: .instruction_courante =
4154: instruction_courante;
4155: return(d_erreur);
4156: }
4157:
4158: if ((*(*s_etat_processus)
4159: .l_base_pile_systeme)
4160: .type_cloture == 'Q')
4161: {
4162: if (pthread_mutex_unlock(
4163: &mutex_sections_critiques)
4164: != 0)
4165: {
4166: (*s_etat_processus)
4167: .erreur_systeme =
4168: d_es_processus;
4169:
4170: if (presence_egalite ==
4171: d_vrai)
4172: {
4173: liberation(
4174: s_etat_processus,
4175: s_objet_evalue);
4176: }
4177:
4178: (*s_etat_processus)
4179: .instruction_courante =
4180: instruction_courante;
4181: return(d_erreur);
4182: }
4183:
4184: (*s_etat_processus)
4185: .sections_critiques--;
4186: }
4187:
4188: depilement_pile_systeme(
4189: s_etat_processus);
4190:
4191: if ((*s_etat_processus)
4192: .erreur_systeme != d_es)
4193: {
4194: if (presence_egalite ==
4195: d_vrai)
4196: {
4197: liberation(
4198: s_etat_processus,
4199: s_objet_evalue);
4200: }
4201:
4202: (*s_etat_processus)
4203: .instruction_courante =
4204: instruction_courante;
4205: return(d_erreur);
4206: }
4207: }
4208: }
4209: }
4210: }
4211: }
4212:
4213: (*s_etat_processus).instruction_courante =
4214: instruction_courante;
4215: drapeau_then = d_faux;
4216:
4217: do
4218: {
4219: l_registre_atome = l_element_courant;
4220:
4221: if (l_element_courant == NULL)
4222: {
4223: /*
4224: * La fin de l'expression est atteinte,
4225: * le sequenceur reprend la main.
4226: */
4227:
4228: if (presence_egalite == d_vrai)
4229: {
4230: liberation(s_etat_processus,
4231: s_objet_evalue);
4232: }
4233:
4234: (*s_etat_processus)
4235: .mode_execution_programme =
4236: registre_mode_execution_programme;
4237: (*s_etat_processus).instruction_courante =
4238: instruction_courante;
4239: return(d_absence_erreur);
4240: }
4241:
4242: if ((*(*l_element_courant).donnee).type == FCT)
4243: {
4244: (*s_etat_processus)
4245: .instruction_courante =
4246: (*((struct_fonction *)
4247: (*(*l_element_courant).donnee)
4248: .objet)).nom_fonction;
4249: fonction = (*((struct_fonction *)
4250: (*(*l_element_courant).donnee)
4251: .objet)).fonction;
4252: (*s_etat_processus).instruction_courante =
4253: instruction_courante;
4254:
4255: drapeau_then = TEST(instruction_then)
4256: ? d_vrai : d_faux;
4257: }
4258:
4259: l_element_courant = (*l_element_courant)
4260: .suivant;
4261: } while(drapeau_then == d_faux);
4262:
4263: (*s_etat_processus).expression_courante =
4264: l_registre_atome;
4265:
4266: (*(*s_etat_processus).l_base_pile_systeme)
4267: .clause = 'X';
4268: instruction_then(s_etat_processus);
4269:
4270: (*s_etat_processus).exception = d_ep;
4271: (*s_etat_processus).erreur_execution = d_ex;
4272: }
4273: else if ((*s_etat_processus).mode_evaluation_expression
4274: == 'Y')
4275: {
4276: /*
4277: * Reprise sur erreur
4278: */
4279:
4280: while(l_element_courant != NULL)
4281: {
4282: if ((*(*l_element_courant).donnee).type == FCT)
4283: {
4284: (*s_etat_processus).instruction_courante =
4285: (*((struct_fonction *)
4286: (*(*l_element_courant).donnee)
4287: .objet)).nom_fonction;
4288: fonction = (*((struct_fonction *)
4289: (*(*l_element_courant).donnee)
4290: .objet)).fonction;
4291:
4292: if (recherche_variable(s_etat_processus,
4293: (*s_etat_processus)
4294: .instruction_courante) == d_faux)
4295: {
4296: (*s_etat_processus).erreur_systeme
4297: = d_es;
4298:
4299: /*
4300: * Traitement de la pile système par les
4301: * différentes instructions.
4302: */
4303:
4304: if (TEST(instruction_if) ||
4305: TEST(instruction_iferr) ||
4306: TEST(instruction_do) ||
4307: TEST(instruction_while) ||
4308: TEST(instruction_for) ||
4309: TEST(instruction_forall) ||
4310: TEST(instruction_start) ||
4311: TEST(instruction_select) ||
4312: TEST(instruction_case) ||
4313: TEST(instruction_critical) ||
4314: TEST(vers_niveau_superieur))
4315: {
4316: if (TEST(vers_niveau_superieur))
4317: {
4318: analyse(s_etat_processus,
4319: vers_niveau_superieur);
4320:
4321: if ((*s_etat_processus)
4322: .erreur_systeme != d_es)
4323: {
4324: if (presence_egalite ==
4325: d_vrai)
4326: {
4327: liberation(
4328: s_etat_processus,
4329: s_objet_evalue);
4330: }
4331:
4332: (*s_etat_processus)
4333: .instruction_courante =
4334: instruction_courante;
4335: return(d_erreur);
4336: }
4337: }
4338: else if (TEST(instruction_for) ||
4339: TEST(instruction_forall) ||
4340: TEST(instruction_start))
4341: {
4342: empilement_pile_systeme(
4343: s_etat_processus);
4344:
4345: if ((*s_etat_processus)
4346: .erreur_systeme != d_es)
4347: {
4348: if (presence_egalite ==
4349: d_vrai)
4350: {
4351: liberation(
4352: s_etat_processus,
4353: s_objet_evalue);
4354: }
4355:
4356: (*s_etat_processus)
4357: .instruction_courante =
4358: instruction_courante;
4359: return(d_erreur);
4360: }
4361:
4362: (*(*s_etat_processus)
4363: .l_base_pile_systeme)
4364: .type_cloture = 'L';
4365: }
4366: else
4367: {
4368: empilement_pile_systeme(
4369: s_etat_processus);
4370:
4371: if ((*s_etat_processus)
4372: .erreur_systeme != d_es)
4373: {
4374: if (presence_egalite ==
4375: d_vrai)
4376: {
4377: liberation(
4378: s_etat_processus,
4379: s_objet_evalue);
4380: }
4381:
4382: (*s_etat_processus)
4383: .instruction_courante =
4384: instruction_courante;
4385: return(d_erreur);
4386: }
4387: }
4388: }
4389: else if (TEST(instruction_end) ||
4390: TEST(instruction_next) ||
4391: TEST(instruction_step) ||
4392: TEST(vers_niveau_inferieur))
4393: {
4394: if (TEST(vers_niveau_inferieur))
4395: {
4396: analyse(s_etat_processus,
4397: vers_niveau_inferieur);
4398:
4399: if ((*s_etat_processus)
4400: .erreur_systeme != d_es)
4401: {
4402: if (presence_egalite ==
4403: d_vrai)
4404: {
4405: liberation(
4406: s_etat_processus,
4407: s_objet_evalue);
4408: }
4409:
4410: (*s_etat_processus)
4411: .instruction_courante =
4412: instruction_courante;
4413: return(d_erreur);
4414: }
4415: }
4416: else if ((TEST(instruction_next) ||
4417: TEST(instruction_step)) &&
4418: ((*(*s_etat_processus)
4419: .l_base_pile_systeme)
4420: .type_cloture != 'L'))
4421: {
4422: /*
4423: * Libération des compteurs
4424: * de boucle
4425: */
4426:
4427: presence_compteur =
4428: (((*(*s_etat_processus)
4429: .l_base_pile_systeme)
4430: .type_cloture == 'F') ||
4431: ((*(*s_etat_processus)
4432: .l_base_pile_systeme)
4433: .type_cloture == 'A'))
4434: ? d_vrai : d_faux;
4435:
4436: if (((*(*s_etat_processus)
4437: .l_base_pile_systeme)
4438: .type_cloture != 'S') &&
4439: (presence_compteur ==
4440: d_faux))
4441: {
4442: (*s_etat_processus)
4443: .erreur_execution =
4444: d_ex_erreur_traitement_boucle;
4445:
4446: if (presence_egalite ==
4447: d_vrai)
4448: {
4449: liberation(
4450: s_etat_processus,
4451: s_objet_evalue);
4452: }
4453:
4454: (*s_etat_processus)
4455: .instruction_courante =
4456: instruction_courante;
4457: return(d_erreur);
4458: }
4459:
4460: if (presence_compteur == d_vrai)
4461: {
4462: if (recherche_variable(
4463: s_etat_processus,
4464: (*(*s_etat_processus)
4465: .l_base_pile_systeme)
4466: .nom_variable) ==
4467: d_faux)
4468: {
4469: (*s_etat_processus)
4470: .erreur_systeme = d_es;
4471: (*s_etat_processus)
4472: .erreur_execution =
4473: d_ex_erreur_traitement_boucle;
4474:
4475: if (presence_egalite ==
4476: d_vrai)
4477: {
4478: liberation(
4479: s_etat_processus,
4480: s_objet_evalue);
4481: }
4482:
4483: (*s_etat_processus)
4484: .instruction_courante =
4485: instruction_courante;
4486: return(d_erreur);
4487: }
4488:
4489: if ((*(*s_etat_processus)
4490: .pointeur_variable_courante)
4491: .objet == NULL)
4492: {
4493: (*s_etat_processus)
4494: .erreur_systeme = d_es;
4495: (*s_etat_processus)
4496: .erreur_execution =
4497: d_ex_variable_partagee;
4498:
4499: if (presence_egalite ==
4500: d_vrai)
4501: {
4502: liberation(
4503: s_etat_processus,
4504: s_objet_evalue);
4505: }
4506:
4507: (*s_etat_processus)
4508: .instruction_courante =
4509: instruction_courante;
4510: return(d_erreur);
4511: }
4512:
4513: (*s_etat_processus)
4514: .niveau_courant--;
4515:
4516: if (
4517: retrait_variables_par_niveau(
4518: s_etat_processus) == d_erreur)
4519: {
4520: if (presence_egalite ==
4521: d_vrai)
4522: {
4523: liberation(
4524: s_etat_processus,
4525: s_objet_evalue);
4526: }
4527:
4528: (*s_etat_processus)
4529: .instruction_courante =
4530: instruction_courante;
4531: return(d_erreur);
4532: }
4533: }
4534:
4535: depilement_pile_systeme(
4536: s_etat_processus);
4537: }
4538: else
4539: {
4540: // Traitement spécifique pour la
4541: // fin d'une section critique
4542:
4543: if ((*s_etat_processus)
4544: .l_base_pile_systeme ==
4545: NULL)
4546: {
4547: (*s_etat_processus)
4548: .erreur_systeme =
4549: d_es_end_incoherent;
4550:
4551: if (presence_egalite ==
4552: d_vrai)
4553: {
4554: liberation(
4555: s_etat_processus,
4556: s_objet_evalue);
4557: }
4558:
4559: (*s_etat_processus)
4560: .instruction_courante =
4561: instruction_courante;
4562: return(d_erreur);
4563: }
4564:
4565: if ((*(*s_etat_processus)
4566: .l_base_pile_systeme)
4567: .type_cloture == 'Q')
4568: {
4569: if (pthread_mutex_unlock(
4570: &mutex_sections_critiques)
4571: != 0)
4572: {
4573: (*s_etat_processus)
4574: .erreur_systeme =
4575: d_es_processus;
4576:
4577: if (presence_egalite ==
4578: d_vrai)
4579: {
4580: liberation(
4581: s_etat_processus,
4582: s_objet_evalue);
4583: }
4584:
4585: (*s_etat_processus)
4586: .instruction_courante =
4587: instruction_courante;
4588: return(d_erreur);
4589: }
4590:
4591: (*s_etat_processus)
4592: .sections_critiques--;
4593: }
4594:
4595: depilement_pile_systeme(
4596: s_etat_processus);
4597:
4598: if ((*s_etat_processus)
4599: .erreur_systeme != d_es)
4600: {
4601: if (presence_egalite ==
4602: d_vrai)
4603: {
4604: liberation(
4605: s_etat_processus,
4606: s_objet_evalue);
4607: }
4608:
4609: (*s_etat_processus)
4610: .instruction_courante =
4611: instruction_courante;
4612: return(d_erreur);
4613: }
4614: }
4615: }
4616: }
4617: }
4618:
4619: l_element_courant =
4620: (*l_element_courant).suivant;
4621: }
4622:
4623: (*s_etat_processus).mode_execution_programme =
4624: registre_mode_execution_programme;
4625: (*s_etat_processus).instruction_courante =
4626: instruction_courante;
4627:
4628: (*s_etat_processus).exception = d_ep;
4629: (*s_etat_processus).erreur_execution = d_ex;
4630:
4631: erreur_evaluation = d_erreur;
4632: }
4633: else
4634: {
4635: // On ne détruit pas les variables pour les inclure
4636: // dans le fichier rpl-core.
4637:
4638: (*s_etat_processus).gel_liste_variables = d_vrai;
4639:
4640: registre_erreur_execution =
4641: (*s_etat_processus).erreur_execution;
4642: registre_exception =
4643: (*s_etat_processus).exception;
4644: registre_erreur_systeme =
4645: (*s_etat_processus).erreur_systeme;
4646:
4647: (*s_etat_processus).s_objet_errone = s_objet;
4648: (*s_etat_processus).s_objet_erreur =
4649: (*l_element_courant).donnee;
4650:
4651: l_element_courant = (*l_element_courant).suivant;
4652:
4653: while(l_element_courant != NULL)
4654: {
4655: if ((*(*l_element_courant).donnee).type == FCT)
4656: {
4657: (*s_etat_processus).instruction_courante =
4658: (*((struct_fonction *)
4659: (*(*l_element_courant).donnee)
4660: .objet)).nom_fonction;
4661: fonction = (*((struct_fonction *)
4662: (*(*l_element_courant).donnee)
4663: .objet)).fonction;
4664:
4665: if (recherche_variable(s_etat_processus,
4666: (*s_etat_processus)
4667: .instruction_courante) == d_faux)
4668: {
4669: (*s_etat_processus).erreur_systeme
4670: = d_es;
4671:
4672: /*
4673: * Traitement de la pile système par les
4674: * différentes instructions.
4675: */
4676:
4677: if (TEST(instruction_if) ||
4678: TEST(instruction_iferr) ||
4679: TEST(instruction_do) ||
4680: TEST(instruction_while) ||
4681: TEST(instruction_for) ||
4682: TEST(instruction_forall) ||
4683: TEST(instruction_start) ||
4684: TEST(instruction_select) ||
4685: TEST(instruction_case) ||
4686: TEST(instruction_critical) ||
4687: TEST(vers_niveau_superieur))
4688: {
4689: if (TEST(vers_niveau_superieur))
4690: {
4691: analyse(s_etat_processus,
4692: vers_niveau_superieur);
4693:
4694: if ((*s_etat_processus)
4695: .erreur_systeme != d_es)
4696: {
4697: if (presence_egalite ==
4698: d_vrai)
4699: {
4700: liberation(
4701: s_etat_processus,
4702: s_objet_evalue);
4703: }
4704:
4705: (*s_etat_processus)
4706: .instruction_courante =
4707: instruction_courante;
4708: return(d_erreur);
4709: }
4710: }
4711: else if (TEST(instruction_for) ||
4712: TEST(instruction_forall) ||
4713: TEST(instruction_start))
4714: {
4715: empilement_pile_systeme(
4716: s_etat_processus);
4717:
4718: if ((*s_etat_processus)
4719: .erreur_systeme != d_es)
4720: {
4721: if (presence_egalite ==
4722: d_vrai)
4723: {
4724: liberation(
4725: s_etat_processus,
4726: s_objet_evalue);
4727: }
4728:
4729: (*s_etat_processus)
4730: .instruction_courante =
4731: instruction_courante;
4732: return(d_erreur);
4733: }
4734:
4735: (*(*s_etat_processus)
4736: .l_base_pile_systeme)
4737: .type_cloture = 'L';
4738: }
4739: else
4740: {
4741: empilement_pile_systeme(
4742: s_etat_processus);
4743:
4744: if ((*s_etat_processus)
4745: .erreur_systeme != d_es)
4746: {
4747: if (presence_egalite ==
4748: d_vrai)
4749: {
4750: liberation(
4751: s_etat_processus,
4752: s_objet_evalue);
4753: }
4754:
4755: (*s_etat_processus)
4756: .instruction_courante =
4757: instruction_courante;
4758: return(d_erreur);
4759: }
4760: }
4761: }
4762: else if (TEST(instruction_end) ||
4763: TEST(instruction_next) ||
4764: TEST(instruction_step) ||
4765: TEST(vers_niveau_inferieur))
4766: {
4767: if (TEST(vers_niveau_inferieur))
4768: {
4769: analyse(s_etat_processus,
4770: vers_niveau_inferieur);
4771:
4772: if ((*s_etat_processus)
4773: .erreur_systeme != d_es)
4774: {
4775: if (presence_egalite ==
4776: d_vrai)
4777: {
4778: liberation(
4779: s_etat_processus,
4780: s_objet_evalue);
4781: }
4782:
4783: (*s_etat_processus)
4784: .instruction_courante =
4785: instruction_courante;
4786: return(d_erreur);
4787: }
4788: }
4789: else if ((TEST(instruction_next) ||
4790: TEST(instruction_step)) &&
4791: ((*(*s_etat_processus)
4792: .l_base_pile_systeme)
4793: .type_cloture != 'L'))
4794: {
4795: /*
4796: * Libération des compteurs
4797: * de boucle
4798: */
4799:
4800: presence_compteur =
4801: (((*(*s_etat_processus)
4802: .l_base_pile_systeme)
4803: .type_cloture == 'F') ||
4804: ((*(*s_etat_processus)
4805: .l_base_pile_systeme)
4806: .type_cloture == 'A'))
4807: ? d_vrai : d_faux;
4808:
4809: if (((*(*s_etat_processus)
4810: .l_base_pile_systeme)
4811: .type_cloture != 'S') &&
4812: (presence_compteur ==
4813: d_faux))
4814: {
4815: (*s_etat_processus)
4816: .erreur_execution =
4817: d_ex_erreur_traitement_boucle;
4818:
4819: if (presence_egalite ==
4820: d_vrai)
4821: {
4822: liberation(
4823: s_etat_processus,
4824: s_objet_evalue);
4825: }
4826:
4827: (*s_etat_processus)
4828: .instruction_courante =
4829: instruction_courante;
4830: return(d_erreur);
4831: }
4832:
4833: if (presence_compteur == d_vrai)
4834: {
4835: if (recherche_variable(
4836: s_etat_processus,
4837: (*(*s_etat_processus)
4838: .l_base_pile_systeme)
4839: .nom_variable) ==
4840: d_faux)
4841: {
4842: (*s_etat_processus)
4843: .erreur_systeme = d_es;
4844: (*s_etat_processus)
4845: .erreur_execution =
4846: d_ex_erreur_traitement_boucle;
4847:
4848: if (presence_egalite ==
4849: d_vrai)
4850: {
4851: liberation(
4852: s_etat_processus,
4853: s_objet_evalue);
4854: }
4855:
4856: (*s_etat_processus)
4857: .instruction_courante =
4858: instruction_courante;
4859: return(d_erreur);
4860: }
4861:
4862: if ((*(*s_etat_processus)
4863: .pointeur_variable_courante)
4864: .objet == NULL)
4865: {
4866: (*s_etat_processus)
4867: .erreur_systeme = d_es;
4868: (*s_etat_processus)
4869: .erreur_execution =
4870: d_ex_variable_partagee;
4871:
4872: if (presence_egalite ==
4873: d_vrai)
4874: {
4875: liberation(
4876: s_etat_processus,
4877: s_objet_evalue);
4878: }
4879:
4880: (*s_etat_processus)
4881: .instruction_courante =
4882: instruction_courante;
4883: return(d_erreur);
4884: }
4885:
4886: (*s_etat_processus)
4887: .niveau_courant--;
4888:
4889: if (
4890: retrait_variables_par_niveau(
4891: s_etat_processus) == d_erreur)
4892: {
4893: if (presence_egalite ==
4894: d_vrai)
4895: {
4896: liberation(
4897: s_etat_processus,
4898: s_objet_evalue);
4899: }
4900:
4901: (*s_etat_processus)
4902: .instruction_courante =
4903: instruction_courante;
4904: return(d_erreur);
4905: }
4906: }
4907:
4908: depilement_pile_systeme(
4909: s_etat_processus);
4910: }
4911: else
4912: {
4913: // Traitement spécifique pour la
4914: // fin d'une section critique
4915:
4916: if ((*s_etat_processus)
4917: .l_base_pile_systeme ==
4918: NULL)
4919: {
4920: (*s_etat_processus)
4921: .erreur_systeme =
4922: d_es_end_incoherent;
4923:
4924: if (presence_egalite ==
4925: d_vrai)
4926: {
4927: liberation(
4928: s_etat_processus,
4929: s_objet_evalue);
4930: }
4931:
4932: (*s_etat_processus)
4933: .instruction_courante =
4934: instruction_courante;
4935: return(d_erreur);
4936: }
4937:
4938: if ((*(*s_etat_processus)
4939: .l_base_pile_systeme)
4940: .type_cloture == 'Q')
4941: {
4942: if (pthread_mutex_unlock(
4943: &mutex_sections_critiques)
4944: != 0)
4945: {
4946: (*s_etat_processus)
4947: .erreur_systeme =
4948: d_es_processus;
4949:
4950: if (presence_egalite ==
4951: d_vrai)
4952: {
4953: liberation(
4954: s_etat_processus,
4955: s_objet_evalue);
4956: }
4957:
4958: (*s_etat_processus)
4959: .instruction_courante =
4960: instruction_courante;
4961: return(d_erreur);
4962: }
4963:
4964: (*s_etat_processus)
4965: .sections_critiques--;
4966: }
4967:
4968: depilement_pile_systeme(
4969: s_etat_processus);
4970:
4971: if ((*s_etat_processus)
4972: .erreur_systeme != d_es)
4973: {
4974: if (presence_egalite ==
4975: d_vrai)
4976: {
4977: liberation(
4978: s_etat_processus,
4979: s_objet_evalue);
4980: }
4981:
4982: (*s_etat_processus)
4983: .instruction_courante =
4984: instruction_courante;
4985: return(d_erreur);
4986: }
4987: }
4988: }
4989: }
4990: }
4991:
4992: l_element_courant =
4993: (*l_element_courant).suivant;
4994: }
4995:
4996: (*s_etat_processus).mode_execution_programme =
4997: registre_mode_execution_programme;
4998: (*s_etat_processus).instruction_courante =
4999: instruction_courante;
5000:
5001: if (presence_egalite == d_vrai)
5002: {
5003: liberation(s_etat_processus, s_objet_evalue);
5004: }
5005:
5006: if ((*s_etat_processus)
5007: .var_volatile_processus_pere == 0)
5008: {
5009: envoi_signal_processus((*s_etat_processus)
5010: .pid_processus_pere, rpl_sigalrm);
5011: }
5012: else
5013: {
5014: (*s_etat_processus).var_volatile_alarme = -1;
5015: }
5016:
5017: (*s_etat_processus).erreur_execution =
5018: registre_erreur_execution;
5019: (*s_etat_processus).erreur_systeme =
5020: registre_erreur_systeme;
5021: (*s_etat_processus).exception =
5022: registre_exception;
5023: return(d_erreur);
5024: }
5025: }
5026:
5027: if ((*s_etat_processus).erreur_systeme != d_es)
5028: {
5029: if (presence_egalite == d_vrai)
5030: {
5031: liberation(s_etat_processus, s_objet_evalue);
5032: }
5033:
5034: if ((*s_etat_processus).var_volatile_processus_pere
5035: == 0)
5036: {
5037: envoi_signal_processus((*s_etat_processus)
5038: .pid_processus_pere, rpl_sigalrm);
5039: }
5040: else
5041: {
5042: (*s_etat_processus).var_volatile_alarme = -1;
5043: }
5044:
5045: (*s_etat_processus).instruction_courante =
5046: instruction_courante;
5047: return(d_erreur);
5048: }
5049: else if (((*s_etat_processus).erreur_execution != d_ex) ||
5050: ((*s_etat_processus).exception != d_ep))
5051: {
5052: if ((*s_etat_processus).arret_si_exception == d_faux)
5053: {
5054: /*
5055: * Reprise sur erreur
5056: */
5057:
5058: if ((message = messages(s_etat_processus)) == NULL)
5059: {
5060: if (presence_egalite == d_vrai)
5061: {
5062: liberation(s_etat_processus,
5063: s_objet_evalue);
5064: }
5065:
5066: (*s_etat_processus).instruction_courante =
5067: instruction_courante;
5068: return(d_erreur);
5069: }
5070:
5071: free(message);
5072:
5073: while((*(*s_etat_processus).l_base_pile_systeme)
5074: .clause != 'R')
5075: {
5076: l_registre_atome = l_element_courant;
5077: l_element_courant =
5078: (*l_element_courant).suivant;
5079:
5080: if (l_element_courant == NULL)
5081: {
5082: /*
5083: * La fin de l'expression est atteinte,
5084: * le sequenceur reprend la main.
5085: */
5086:
5087: if (presence_egalite == d_vrai)
5088: {
5089: liberation(s_etat_processus,
5090: s_objet_evalue);
5091: }
5092:
5093: (*s_etat_processus)
5094: .mode_execution_programme =
5095: registre_mode_execution_programme;
5096: return(d_absence_erreur);
5097: }
5098:
5099: if ((*(*l_element_courant).donnee).type == FCT)
5100: {
5101: (*s_etat_processus).instruction_courante =
5102: (*((struct_fonction *)
5103: (*(*l_element_courant).donnee)
5104: .objet)).nom_fonction;
5105:
5106: if (recherche_variable(s_etat_processus,
5107: (*s_etat_processus)
5108: .instruction_courante) == d_faux)
5109: {
5110: (*s_etat_processus).erreur_systeme
5111: = d_es;
5112: fonction = (*((struct_fonction *)
5113: (*(*l_element_courant).donnee)
5114: .objet)).fonction;
5115:
5116: /*
5117: * Traitement de la pile système par les
5118: * différentes instructions.
5119: */
5120:
5121: if (TEST(instruction_if) ||
5122: TEST(instruction_iferr) ||
5123: TEST(instruction_do) ||
5124: TEST(instruction_while) ||
5125: TEST(instruction_for) ||
5126: TEST(instruction_forall) ||
5127: TEST(instruction_start) ||
5128: TEST(instruction_select) ||
5129: TEST(instruction_case) ||
5130: TEST(instruction_critical) ||
5131: TEST(vers_niveau_superieur))
5132: {
5133: if (TEST(vers_niveau_superieur))
5134: {
5135: registre_exception =
5136: (*s_etat_processus)
5137: .exception;
5138: registre_erreur_execution =
5139: (*s_etat_processus)
5140: .erreur_execution;
5141:
5142: analyse(s_etat_processus,
5143: vers_niveau_superieur);
5144:
5145: if ((*s_etat_processus)
5146: .erreur_systeme != d_es)
5147: {
5148: if (presence_egalite ==
5149: d_vrai)
5150: {
5151: liberation(
5152: s_etat_processus,
5153: s_objet_evalue);
5154: }
5155:
5156: (*s_etat_processus)
5157: .instruction_courante =
5158: instruction_courante;
5159: return(d_erreur);
5160: }
5161:
5162: (*s_etat_processus).exception
5163: = registre_exception;
5164: (*s_etat_processus)
5165: .erreur_execution =
5166: registre_erreur_execution;
5167: }
5168: else if (TEST(instruction_for) ||
5169: TEST(instruction_forall) ||
5170: TEST(instruction_start))
5171: {
5172: empilement_pile_systeme(
5173: s_etat_processus);
5174:
5175: if ((*s_etat_processus)
5176: .erreur_systeme != d_es)
5177: {
5178: if (presence_egalite ==
5179: d_vrai)
5180: {
5181: liberation(
5182: s_etat_processus,
5183: s_objet_evalue);
5184: }
5185:
5186: (*s_etat_processus)
5187: .instruction_courante =
5188: instruction_courante;
5189: return(d_erreur);
5190: }
5191:
5192: (*(*s_etat_processus)
5193: .l_base_pile_systeme)
5194: .type_cloture = 'L';
5195: }
5196: else
5197: {
5198: empilement_pile_systeme(
5199: s_etat_processus);
5200:
5201: if ((*s_etat_processus)
5202: .erreur_systeme != d_es)
5203: {
5204: if (presence_egalite ==
5205: d_vrai)
5206: {
5207: liberation(
5208: s_etat_processus,
5209: s_objet_evalue);
5210: }
5211:
5212: (*s_etat_processus)
5213: .instruction_courante =
5214: instruction_courante;
5215: return(d_erreur);
5216: }
5217: }
5218: }
5219: else if (TEST(instruction_end) ||
5220: TEST(instruction_next) ||
5221: TEST(instruction_step) ||
5222: TEST(vers_niveau_inferieur))
5223: {
5224: if (TEST(vers_niveau_inferieur))
5225: {
5226: registre_exception =
5227: (*s_etat_processus)
5228: .exception;
5229: registre_erreur_execution =
5230: (*s_etat_processus)
5231: .erreur_execution;
5232:
5233: analyse(s_etat_processus,
5234: vers_niveau_inferieur);
5235:
5236: if ((*s_etat_processus)
5237: .erreur_systeme != d_es)
5238: {
5239: if (presence_egalite ==
5240: d_vrai)
5241: {
5242: liberation(
5243: s_etat_processus,
5244: s_objet_evalue);
5245: }
5246:
5247: (*s_etat_processus)
5248: .instruction_courante =
5249: instruction_courante;
5250: return(d_erreur);
5251: }
5252:
5253: (*s_etat_processus).exception
5254: = registre_exception;
5255: (*s_etat_processus)
5256: .erreur_execution =
5257: registre_erreur_execution;
5258: }
5259: else if ((TEST(instruction_next) ||
5260: TEST(instruction_step)) &&
5261: ((*(*s_etat_processus)
5262: .l_base_pile_systeme)
5263: .type_cloture != 'L'))
5264: {
5265: /*
5266: * Libération des compteurs
5267: * de boucle
5268: */
5269:
5270: presence_compteur =
5271: (((*(*s_etat_processus)
5272: .l_base_pile_systeme)
5273: .type_cloture == 'F') ||
5274: ((*(*s_etat_processus)
5275: .l_base_pile_systeme)
5276: .type_cloture == 'A'))
5277: ? d_vrai : d_faux;
5278:
5279: if (((*(*s_etat_processus)
5280: .l_base_pile_systeme)
5281: .type_cloture != 'S') &&
5282: (presence_compteur ==
5283: d_faux))
5284: {
5285: (*s_etat_processus)
5286: .erreur_execution =
5287: d_ex_erreur_traitement_boucle;
5288:
5289: if (presence_egalite ==
5290: d_vrai)
5291: {
5292: liberation(
5293: s_etat_processus,
5294: s_objet_evalue);
5295: }
5296:
5297: (*s_etat_processus)
5298: .instruction_courante =
5299: instruction_courante;
5300: return(d_erreur);
5301: }
5302:
5303: if (presence_compteur == d_vrai)
5304: {
5305: if (recherche_variable(
5306: s_etat_processus,
5307: (*(*s_etat_processus)
5308: .l_base_pile_systeme)
5309: .nom_variable) ==
5310: d_faux)
5311: {
5312: (*s_etat_processus)
5313: .erreur_systeme = d_es;
5314: (*s_etat_processus)
5315: .erreur_execution =
5316: d_ex_erreur_traitement_boucle;
5317:
5318: if (presence_egalite ==
5319: d_vrai)
5320: {
5321: liberation(
5322: s_etat_processus,
5323: s_objet_evalue);
5324: }
5325:
5326: (*s_etat_processus)
5327: .instruction_courante =
5328: instruction_courante;
5329: return(d_erreur);
5330: }
5331:
5332: if ((*(*s_etat_processus)
5333: .pointeur_variable_courante)
5334: .objet == NULL)
5335: {
5336: (*s_etat_processus)
5337: .erreur_systeme = d_es;
5338: (*s_etat_processus)
5339: .erreur_execution =
5340: d_ex_variable_partagee;
5341:
5342: if (presence_egalite ==
5343: d_vrai)
5344: {
5345: liberation(
5346: s_etat_processus,
5347: s_objet_evalue);
5348: }
5349:
5350: (*s_etat_processus)
5351: .instruction_courante =
5352: instruction_courante;
5353: return(d_erreur);
5354: }
5355:
5356: (*s_etat_processus)
5357: .niveau_courant--;
5358:
5359: if (
5360: retrait_variables_par_niveau(
5361: s_etat_processus) == d_erreur)
5362: {
5363: if (presence_egalite ==
5364: d_vrai)
5365: {
5366: liberation(
5367: s_etat_processus,
5368: s_objet_evalue);
5369: }
5370:
5371: (*s_etat_processus)
5372: .instruction_courante =
5373: instruction_courante;
5374: return(d_erreur);
5375: }
5376: }
5377:
5378: depilement_pile_systeme(
5379: s_etat_processus);
5380: }
5381: else
5382: {
5383: // Traitement spécifique pour la
5384: // fin d'une section critique
5385:
5386: if ((*s_etat_processus)
5387: .l_base_pile_systeme ==
5388: NULL)
5389: {
5390: (*s_etat_processus)
5391: .erreur_systeme =
5392: d_es_end_incoherent;
5393:
5394: if (presence_egalite ==
5395: d_vrai)
5396: {
5397: liberation(
5398: s_etat_processus,
5399: s_objet_evalue);
5400: }
5401:
5402: (*s_etat_processus)
5403: .instruction_courante =
5404: instruction_courante;
5405: return(d_erreur);
5406: }
5407:
5408: if ((*(*s_etat_processus)
5409: .l_base_pile_systeme)
5410: .type_cloture == 'Q')
5411: {
5412: if (pthread_mutex_unlock(
5413: &mutex_sections_critiques)
5414: != 0)
5415: {
5416: (*s_etat_processus)
5417: .erreur_systeme =
5418: d_es_processus;
5419:
5420: if (presence_egalite ==
5421: d_vrai)
5422: {
5423: liberation(
5424: s_etat_processus,
5425: s_objet_evalue);
5426: }
5427:
5428: (*s_etat_processus)
5429: .instruction_courante =
5430: instruction_courante;
5431: return(d_erreur);
5432: }
5433:
5434: (*s_etat_processus)
5435: .sections_critiques--;
5436: }
5437:
5438: depilement_pile_systeme(
5439: s_etat_processus);
5440:
5441: if ((*s_etat_processus)
5442: .erreur_systeme != d_es)
5443: {
5444: if (presence_egalite ==
5445: d_vrai)
5446: {
5447: liberation(
5448: s_etat_processus,
5449: s_objet_evalue);
5450: }
5451:
5452: (*s_etat_processus)
5453: .instruction_courante =
5454: instruction_courante;
5455: return(d_erreur);
5456: }
5457: }
5458: }
5459: }
5460: }
5461: }
5462:
5463: (*s_etat_processus).instruction_courante =
5464: instruction_courante;
5465: drapeau_then = d_faux;
5466:
5467: do
5468: {
5469: l_registre_atome = l_element_courant;
5470:
5471: if (l_element_courant == NULL)
5472: {
5473: /*
5474: * La fin de l'expression est atteinte,
5475: * le séquenceur reprend la main.
5476: */
5477:
5478: if (presence_egalite == d_vrai)
5479: {
5480: liberation(s_etat_processus,
5481: s_objet_evalue);
5482: }
5483:
5484: (*s_etat_processus)
5485: .mode_execution_programme =
5486: registre_mode_execution_programme;
5487: (*s_etat_processus).instruction_courante =
5488: instruction_courante;
5489: return(d_absence_erreur);
5490: }
5491:
5492: if ((*(*l_element_courant).donnee).type == FCT)
5493: {
5494: (*s_etat_processus)
5495: .instruction_courante =
5496: (*((struct_fonction *)
5497: (*(*l_element_courant).donnee)
5498: .objet)).nom_fonction;
5499: fonction = (*((struct_fonction *)
5500: (*(*l_element_courant).donnee)
5501: .objet)).fonction;
5502: (*s_etat_processus).instruction_courante =
5503: instruction_courante;
5504:
5505: drapeau_then = TEST(instruction_then)
5506: ? d_vrai : d_faux;
5507: }
5508:
5509: l_element_courant = (*l_element_courant)
5510: .suivant;
5511: } while(drapeau_then == d_faux);
5512:
5513: (*s_etat_processus).expression_courante =
5514: l_registre_atome;
5515:
5516: (*(*s_etat_processus).l_base_pile_systeme)
5517: .clause = 'X';
5518: instruction_then(s_etat_processus);
5519:
5520: (*s_etat_processus).exception = d_ep;
5521: (*s_etat_processus).erreur_execution = d_ex;
5522: }
5523: else if ((*s_etat_processus).mode_evaluation_expression
5524: == 'Y')
5525: {
5526: /*
5527: * Reprise sur erreur
5528: */
5529:
5530: while(l_element_courant != NULL)
5531: {
5532: if ((*(*l_element_courant).donnee).type == FCT)
5533: {
5534: (*s_etat_processus).instruction_courante =
5535: (*((struct_fonction *)
5536: (*(*l_element_courant).donnee)
5537: .objet)).nom_fonction;
5538: fonction = (*((struct_fonction *)
5539: (*(*l_element_courant).donnee)
5540: .objet)).fonction;
5541:
5542: if (recherche_variable(s_etat_processus,
5543: (*s_etat_processus)
5544: .instruction_courante) == d_faux)
5545: {
5546: (*s_etat_processus).erreur_systeme
5547: = d_es;
5548:
5549: /*
5550: * Traitement de la pile système par les
5551: * différentes instructions.
5552: */
5553:
5554: if (TEST(instruction_if) ||
5555: TEST(instruction_iferr) ||
5556: TEST(instruction_do) ||
5557: TEST(instruction_while) ||
5558: TEST(instruction_for) ||
5559: TEST(instruction_forall) ||
5560: TEST(instruction_start) ||
5561: TEST(instruction_select) ||
5562: TEST(instruction_case) ||
5563: TEST(instruction_critical) ||
5564: TEST(vers_niveau_superieur))
5565: {
5566: if (TEST(vers_niveau_superieur))
5567: {
5568: analyse(s_etat_processus,
5569: vers_niveau_superieur);
5570:
5571: if ((*s_etat_processus)
5572: .erreur_systeme != d_es)
5573: {
5574: if (presence_egalite ==
5575: d_vrai)
5576: {
5577: liberation(
5578: s_etat_processus,
5579: s_objet_evalue);
5580: }
5581:
5582: (*s_etat_processus)
5583: .instruction_courante =
5584: instruction_courante;
5585: return(d_erreur);
5586: }
5587: }
5588: else if (TEST(instruction_for) ||
5589: TEST(instruction_forall) ||
5590: TEST(instruction_start))
5591: {
5592: empilement_pile_systeme(
5593: s_etat_processus);
5594:
5595: if ((*s_etat_processus)
5596: .erreur_systeme != d_es)
5597: {
5598: if (presence_egalite ==
5599: d_vrai)
5600: {
5601: liberation(
5602: s_etat_processus,
5603: s_objet_evalue);
5604: }
5605:
5606: (*s_etat_processus)
5607: .instruction_courante =
5608: instruction_courante;
5609: return(d_erreur);
5610: }
5611:
5612: (*(*s_etat_processus)
5613: .l_base_pile_systeme)
5614: .type_cloture = 'L';
5615: }
5616: else
5617: {
5618: empilement_pile_systeme(
5619: s_etat_processus);
5620:
5621: if ((*s_etat_processus)
5622: .erreur_systeme != d_es)
5623: {
5624: if (presence_egalite ==
5625: d_vrai)
5626: {
5627: liberation(
5628: s_etat_processus,
5629: s_objet_evalue);
5630: }
5631:
5632: (*s_etat_processus)
5633: .instruction_courante =
5634: instruction_courante;
5635: return(d_erreur);
5636: }
5637: }
5638: }
5639: else if (TEST(instruction_end) ||
5640: TEST(instruction_next) ||
5641: TEST(instruction_step) ||
5642: TEST(vers_niveau_inferieur))
5643: {
5644: if (TEST(vers_niveau_inferieur))
5645: {
5646: analyse(s_etat_processus,
5647: vers_niveau_inferieur);
5648:
5649: if ((*s_etat_processus)
5650: .erreur_systeme != d_es)
5651: {
5652: if (presence_egalite ==
5653: d_vrai)
5654: {
5655: liberation(
5656: s_etat_processus,
5657: s_objet_evalue);
5658: }
5659:
5660: (*s_etat_processus)
5661: .instruction_courante =
5662: instruction_courante;
5663: return(d_erreur);
5664: }
5665: }
5666: else if ((TEST(instruction_next) ||
5667: TEST(instruction_step)) &&
5668: ((*(*s_etat_processus)
5669: .l_base_pile_systeme)
5670: .type_cloture != 'L'))
5671: {
5672: /*
5673: * Libération des compteurs
5674: * de boucle
5675: */
5676:
5677: presence_compteur =
5678: (((*(*s_etat_processus)
5679: .l_base_pile_systeme)
5680: .type_cloture == 'F') ||
5681: ((*(*s_etat_processus)
5682: .l_base_pile_systeme)
5683: .type_cloture == 'A'))
5684: ? d_vrai : d_faux;
5685:
5686: if (((*(*s_etat_processus)
5687: .l_base_pile_systeme)
5688: .type_cloture != 'S') &&
5689: (presence_compteur ==
5690: d_faux))
5691: {
5692: (*s_etat_processus)
5693: .erreur_execution =
5694: d_ex_erreur_traitement_boucle;
5695:
5696: if (presence_egalite ==
5697: d_vrai)
5698: {
5699: liberation(
5700: s_etat_processus,
5701: s_objet_evalue);
5702: }
5703:
5704: (*s_etat_processus)
5705: .instruction_courante =
5706: instruction_courante;
5707: return(d_erreur);
5708: }
5709:
5710: if (presence_compteur == d_vrai)
5711: {
5712: if (recherche_variable(
5713: s_etat_processus,
5714: (*(*s_etat_processus)
5715: .l_base_pile_systeme)
5716: .nom_variable) ==
5717: d_faux)
5718: {
5719: (*s_etat_processus)
5720: .erreur_systeme = d_es;
5721: (*s_etat_processus)
5722: .erreur_execution =
5723: d_ex_erreur_traitement_boucle;
5724:
5725: if (presence_egalite ==
5726: d_vrai)
5727: {
5728: liberation(
5729: s_etat_processus,
5730: s_objet_evalue);
5731: }
5732:
5733: (*s_etat_processus)
5734: .instruction_courante =
5735: instruction_courante;
5736: return(d_erreur);
5737: }
5738:
5739: if ((*(*s_etat_processus)
5740: .pointeur_variable_courante)
5741: .objet == NULL)
5742: {
5743: (*s_etat_processus)
5744: .erreur_systeme = d_es;
5745: (*s_etat_processus)
5746: .erreur_execution =
5747: d_ex_variable_partagee;
5748:
5749: if (presence_egalite ==
5750: d_vrai)
5751: {
5752: liberation(
5753: s_etat_processus,
5754: s_objet_evalue);
5755: }
5756:
5757: (*s_etat_processus)
5758: .instruction_courante =
5759: instruction_courante;
5760: return(d_erreur);
5761: }
5762:
5763: (*s_etat_processus)
5764: .niveau_courant--;
5765:
5766: if (
5767: retrait_variables_par_niveau(
5768: s_etat_processus) == d_erreur)
5769: {
5770: if (presence_egalite ==
5771: d_vrai)
5772: {
5773: liberation(
5774: s_etat_processus,
5775: s_objet_evalue);
5776: }
5777:
5778: (*s_etat_processus)
5779: .instruction_courante =
5780: instruction_courante;
5781: return(d_erreur);
5782: }
5783: }
5784:
5785: depilement_pile_systeme(
5786: s_etat_processus);
5787: }
5788: else
5789: {
5790: // Traitement spécifique pour la
5791: // fin d'une section critique
5792:
5793: if ((*s_etat_processus)
5794: .l_base_pile_systeme ==
5795: NULL)
5796: {
5797: (*s_etat_processus)
5798: .erreur_systeme =
5799: d_es_end_incoherent;
5800:
5801: if (presence_egalite ==
5802: d_vrai)
5803: {
5804: liberation(
5805: s_etat_processus,
5806: s_objet_evalue);
5807: }
5808:
5809: (*s_etat_processus)
5810: .instruction_courante =
5811: instruction_courante;
5812: return(d_erreur);
5813: }
5814:
5815: if ((*(*s_etat_processus)
5816: .l_base_pile_systeme)
5817: .type_cloture == 'Q')
5818: {
5819: if (pthread_mutex_unlock(
5820: &mutex_sections_critiques)
5821: != 0)
5822: {
5823: (*s_etat_processus)
5824: .erreur_systeme =
5825: d_es_processus;
5826:
5827: if (presence_egalite ==
5828: d_vrai)
5829: {
5830: liberation(
5831: s_etat_processus,
5832: s_objet_evalue);
5833: }
5834:
5835: (*s_etat_processus)
5836: .instruction_courante =
5837: instruction_courante;
5838: return(d_erreur);
5839: }
5840:
5841: (*s_etat_processus)
5842: .sections_critiques--;
5843: }
5844:
5845: depilement_pile_systeme(
5846: s_etat_processus);
5847:
5848: if ((*s_etat_processus)
5849: .erreur_systeme != d_es)
5850: {
5851: if (presence_egalite ==
5852: d_vrai)
5853: {
5854: liberation(
5855: s_etat_processus,
5856: s_objet_evalue);
5857: }
5858:
5859: (*s_etat_processus)
5860: .instruction_courante =
5861: instruction_courante;
5862: return(d_erreur);
5863: }
5864: }
5865: }
5866: }
5867: }
5868:
5869: l_element_courant =
5870: (*l_element_courant).suivant;
5871: }
5872:
5873: (*s_etat_processus).mode_execution_programme =
5874: registre_mode_execution_programme;
5875: (*s_etat_processus).instruction_courante =
5876: instruction_courante;
5877:
5878: (*s_etat_processus).exception = d_ep;
5879: (*s_etat_processus).erreur_execution = d_ex;
5880:
5881: erreur_evaluation = d_erreur;
5882: }
5883: else
5884: {
5885: // On ne détruit pas les variables pour les inclure
5886: // dans le fichier rpl-core.
5887:
5888: (*s_etat_processus).gel_liste_variables = d_vrai;
5889:
5890: registre_erreur_execution =
5891: (*s_etat_processus).erreur_execution;
5892: registre_exception =
5893: (*s_etat_processus).exception;
5894: registre_erreur_systeme =
5895: (*s_etat_processus).erreur_systeme;
5896:
5897: (*s_etat_processus).s_objet_errone = s_objet;
5898: (*s_etat_processus).s_objet_erreur =
5899: (*l_element_courant).donnee;
5900:
5901: l_element_courant = (*l_element_courant).suivant;
5902:
5903: while(l_element_courant != NULL)
5904: {
5905: if ((*(*l_element_courant).donnee).type == FCT)
5906: {
5907: (*s_etat_processus).instruction_courante =
5908: (*((struct_fonction *)
5909: (*(*l_element_courant).donnee)
5910: .objet)).nom_fonction;
5911: fonction = (*((struct_fonction *)
5912: (*(*l_element_courant).donnee)
5913: .objet)).fonction;
5914:
5915: if (recherche_variable(s_etat_processus,
5916: (*s_etat_processus)
5917: .instruction_courante) == d_faux)
5918: {
5919: (*s_etat_processus).erreur_systeme
5920: = d_es;
5921:
5922: /*
5923: * Traitement de la pile système par les
5924: * différentes instructions.
5925: */
5926:
5927: if (TEST(instruction_if) ||
5928: TEST(instruction_iferr) ||
5929: TEST(instruction_do) ||
5930: TEST(instruction_while) ||
5931: TEST(instruction_for) ||
5932: TEST(instruction_forall) ||
5933: TEST(instruction_start) ||
5934: TEST(instruction_select) ||
5935: TEST(instruction_case) ||
5936: TEST(instruction_critical) ||
5937: TEST(vers_niveau_superieur))
5938: {
5939: if (TEST(vers_niveau_superieur))
5940: {
5941: analyse(s_etat_processus,
5942: vers_niveau_superieur);
5943:
5944: if ((*s_etat_processus)
5945: .erreur_systeme != d_es)
5946: {
5947: if (presence_egalite ==
5948: d_vrai)
5949: {
5950: liberation(
5951: s_etat_processus,
5952: s_objet_evalue);
5953: }
5954:
5955: (*s_etat_processus)
5956: .instruction_courante =
5957: instruction_courante;
5958: return(d_erreur);
5959: }
5960: }
5961: else if (TEST(instruction_for) ||
5962: TEST(instruction_forall) ||
5963: TEST(instruction_start))
5964: {
5965: empilement_pile_systeme(
5966: s_etat_processus);
5967:
5968: if ((*s_etat_processus)
5969: .erreur_systeme != d_es)
5970: {
5971: if (presence_egalite ==
5972: d_vrai)
5973: {
5974: liberation(
5975: s_etat_processus,
5976: s_objet_evalue);
5977: }
5978:
5979: (*s_etat_processus)
5980: .instruction_courante =
5981: instruction_courante;
5982: return(d_erreur);
5983: }
5984:
5985: (*(*s_etat_processus)
5986: .l_base_pile_systeme)
5987: .type_cloture = 'L';
5988: }
5989: else
5990: {
5991: empilement_pile_systeme(
5992: s_etat_processus);
5993:
5994: if ((*s_etat_processus)
5995: .erreur_systeme != d_es)
5996: {
5997: if (presence_egalite ==
5998: d_vrai)
5999: {
6000: liberation(
6001: s_etat_processus,
6002: s_objet_evalue);
6003: }
6004:
6005: (*s_etat_processus)
6006: .instruction_courante =
6007: instruction_courante;
6008: return(d_erreur);
6009: }
6010: }
6011: }
6012: else if (TEST(instruction_end) ||
6013: TEST(instruction_next) ||
6014: TEST(instruction_step) ||
6015: TEST(vers_niveau_inferieur))
6016: {
6017: if (TEST(vers_niveau_inferieur))
6018: {
6019: analyse(s_etat_processus,
6020: vers_niveau_inferieur);
6021:
6022: if ((*s_etat_processus)
6023: .erreur_systeme != d_es)
6024: {
6025: if (presence_egalite ==
6026: d_vrai)
6027: {
6028: liberation(
6029: s_etat_processus,
6030: s_objet_evalue);
6031: }
6032:
6033: (*s_etat_processus)
6034: .instruction_courante =
6035: instruction_courante;
6036: return(d_erreur);
6037: }
6038: }
6039: else if ((TEST(instruction_next) ||
6040: TEST(instruction_step)) &&
6041: ((*(*s_etat_processus)
6042: .l_base_pile_systeme)
6043: .type_cloture != 'L'))
6044: {
6045: /*
6046: * Libération des compteurs
6047: * de boucle
6048: */
6049:
6050: presence_compteur =
6051: (((*(*s_etat_processus)
6052: .l_base_pile_systeme)
6053: .type_cloture == 'F') ||
6054: ((*(*s_etat_processus)
6055: .l_base_pile_systeme)
6056: .type_cloture == 'A'))
6057: ? d_vrai : d_faux;
6058:
6059: if (((*(*s_etat_processus)
6060: .l_base_pile_systeme)
6061: .type_cloture != 'S') &&
6062: (presence_compteur ==
6063: d_faux))
6064: {
6065: (*s_etat_processus)
6066: .erreur_execution =
6067: d_ex_erreur_traitement_boucle;
6068:
6069: if (presence_egalite ==
6070: d_vrai)
6071: {
6072: liberation(
6073: s_etat_processus,
6074: s_objet_evalue);
6075: }
6076:
6077: (*s_etat_processus)
6078: .instruction_courante =
6079: instruction_courante;
6080: return(d_erreur);
6081: }
6082:
6083: if (presence_compteur == d_vrai)
6084: {
6085: if (recherche_variable(
6086: s_etat_processus,
6087: (*(*s_etat_processus)
6088: .l_base_pile_systeme)
6089: .nom_variable) ==
6090: d_faux)
6091: {
6092: (*s_etat_processus)
6093: .erreur_systeme = d_es;
6094: (*s_etat_processus)
6095: .erreur_execution =
6096: d_ex_erreur_traitement_boucle;
6097:
6098: if (presence_egalite ==
6099: d_vrai)
6100: {
6101: liberation(
6102: s_etat_processus,
6103: s_objet_evalue);
6104: }
6105:
6106: (*s_etat_processus)
6107: .instruction_courante =
6108: instruction_courante;
6109: return(d_erreur);
6110: }
6111:
6112: if ((*(*s_etat_processus)
6113: .pointeur_variable_courante)
6114: .objet == NULL)
6115: {
6116: (*s_etat_processus)
6117: .erreur_systeme = d_es;
6118: (*s_etat_processus)
6119: .erreur_execution =
6120: d_ex_variable_partagee;
6121:
6122: if (presence_egalite ==
6123: d_vrai)
6124: {
6125: liberation(
6126: s_etat_processus,
6127: s_objet_evalue);
6128: }
6129:
6130: (*s_etat_processus)
6131: .instruction_courante =
6132: instruction_courante;
6133: return(d_erreur);
6134: }
6135:
6136: (*s_etat_processus)
6137: .niveau_courant--;
6138:
6139: if (
6140: retrait_variables_par_niveau(
6141: s_etat_processus) == d_erreur)
6142: {
6143: if (presence_egalite ==
6144: d_vrai)
6145: {
6146: liberation(
6147: s_etat_processus,
6148: s_objet_evalue);
6149: }
6150:
6151: (*s_etat_processus)
6152: .instruction_courante =
6153: instruction_courante;
6154: return(d_erreur);
6155: }
6156: }
6157:
6158: depilement_pile_systeme(
6159: s_etat_processus);
6160: }
6161: else
6162: {
6163: // Traitement spécifique pour la
6164: // fin d'une section critique
6165:
6166: if ((*s_etat_processus)
6167: .l_base_pile_systeme ==
6168: NULL)
6169: {
6170: (*s_etat_processus)
6171: .erreur_systeme =
6172: d_es_end_incoherent;
6173:
6174: if (presence_egalite ==
6175: d_vrai)
6176: {
6177: liberation(
6178: s_etat_processus,
6179: s_objet_evalue);
6180: }
6181:
6182: (*s_etat_processus)
6183: .instruction_courante =
6184: instruction_courante;
6185: return(d_erreur);
6186: }
6187:
6188: if ((*(*s_etat_processus)
6189: .l_base_pile_systeme)
6190: .type_cloture == 'Q')
6191: {
6192: if (pthread_mutex_unlock(
6193: &mutex_sections_critiques)
6194: != 0)
6195: {
6196: (*s_etat_processus)
6197: .erreur_systeme =
6198: d_es_processus;
6199:
6200: if (presence_egalite ==
6201: d_vrai)
6202: {
6203: liberation(
6204: s_etat_processus,
6205: s_objet_evalue);
6206: }
6207:
6208: (*s_etat_processus)
6209: .instruction_courante =
6210: instruction_courante;
6211: return(d_erreur);
6212: }
6213:
6214: (*s_etat_processus)
6215: .sections_critiques--;
6216: }
6217:
6218: depilement_pile_systeme(
6219: s_etat_processus);
6220:
6221: if ((*s_etat_processus)
6222: .erreur_systeme != d_es)
6223: {
6224: if (presence_egalite ==
6225: d_vrai)
6226: {
6227: liberation(
6228: s_etat_processus,
6229: s_objet_evalue);
6230: }
6231:
6232: (*s_etat_processus)
6233: .instruction_courante =
6234: instruction_courante;
6235: return(d_erreur);
6236: }
6237: }
6238: }
6239: }
6240: }
6241:
6242: l_element_courant =
6243: (*l_element_courant).suivant;
6244: }
6245:
6246: (*s_etat_processus).mode_execution_programme =
6247: registre_mode_execution_programme;
6248: (*s_etat_processus).instruction_courante =
6249: instruction_courante;
6250: if (presence_egalite == d_vrai)
6251: {
6252: liberation(s_etat_processus, s_objet_evalue);
6253: }
6254:
6255: if ((*s_etat_processus)
6256: .var_volatile_processus_pere == 0)
6257: {
6258: envoi_signal_processus((*s_etat_processus)
6259: .pid_processus_pere, rpl_sigalrm);
6260: }
6261: else
6262: {
6263: (*s_etat_processus).var_volatile_alarme = -1;
6264: }
6265:
6266: (*s_etat_processus).erreur_execution =
6267: registre_erreur_execution;
6268: (*s_etat_processus).erreur_systeme =
6269: registre_erreur_systeme;
6270: (*s_etat_processus).exception =
6271: registre_exception;
6272: return(d_erreur);
6273: }
6274: }
6275: }
6276: else if ((*s_etat_processus).constante_symbolique == 'N')
6277: {
6278: if ((s_objet_elementaire = copie_objet(s_etat_processus,
6279: (*l_element_courant).donnee, 'P')) == NULL)
6280: {
6281: if (presence_egalite == d_vrai)
6282: {
6283: liberation(s_etat_processus, s_objet_evalue);
6284: }
6285:
6286: (*s_etat_processus).erreur_systeme =
6287: d_es_allocation_memoire;
6288: (*s_etat_processus).instruction_courante =
6289: instruction_courante;
6290: return(d_erreur);
6291: }
6292:
6293: presence_fonction = d_faux;
6294: presence_variable_partagee = d_faux;
6295:
6296: if (recherche_variable(s_etat_processus, (*((struct_nom *)
6297: (*s_objet_elementaire).objet)).nom) == d_faux)
6298: {
6299: (*s_etat_processus).erreur_systeme = d_es;
6300: presence_variable = d_faux;
6301:
6302: if ((*s_etat_processus).autorisation_nom_implicite
6303: == 'N')
6304: {
6305: if ((*((struct_nom *) (*s_objet_elementaire).objet))
6306: .symbole == d_faux)
6307: {
6308: if (test_cfsf(s_etat_processus, 31) == d_vrai)
6309: {
6310: if (empilement_pile_last(s_etat_processus,
6311: 0) == d_erreur)
6312: {
6313: return(d_erreur);
6314: }
6315: }
6316:
6317: erreur_evaluation = d_erreur;
6318: (*s_etat_processus).erreur_execution =
6319: d_ex_nom_implicite;
6320:
6321: if (type_evaluation == 'I')
6322: {
6323: (*s_etat_processus)
6324: .derniere_erreur_evaluation =
6325: (*s_etat_processus)
6326: .erreur_execution;
6327: }
6328: }
6329: }
6330: }
6331: else
6332: {
6333: if ((*s_etat_processus).traitement_symbolique == 'N')
6334: {
6335: if ((*(*s_etat_processus)
6336: .pointeur_variable_courante).objet == NULL)
6337: {
6338: // Variable partagée
6339:
6340: presence_variable_partagee = d_faux;
6341:
6342: if (recherche_variable_partagee(
6343: s_etat_processus, (*(*s_etat_processus)
6344: .pointeur_variable_courante).nom,
6345: (*(*s_etat_processus)
6346: .pointeur_variable_courante)
6347: .variable_partagee, 'E') != NULL)
6348: {
6349: presence_variable = d_vrai;
6350: presence_variable_partagee = d_vrai;
6351:
6352: if ((*(*(*s_etat_processus)
6353: .pointeur_variable_partagee_courante
6354: ).objet).type == ADR)
6355: {
6356: presence_fonction = d_vrai;
6357: }
6358:
6359: if ((type_evaluation == 'N') ||
6360: ((*((struct_nom *)
6361: (*(*l_element_courant).donnee)
6362: .objet)).symbole == d_faux))
6363: {
6364: if ((s_copie_variable_partagee =
6365: copie_objet(s_etat_processus,
6366: (*(*s_etat_processus)
6367: .pointeur_variable_partagee_courante
6368: ).objet, 'P')) == NULL)
6369: {
6370: if (pthread_mutex_unlock(
6371: &((*(*s_etat_processus)
6372: .pointeur_variable_partagee_courante
6373: ).mutex)) != 0)
6374: {
6375: (*s_etat_processus)
6376: .erreur_systeme =
6377: d_es_processus;
6378: return(d_erreur);
6379: }
6380: }
6381: }
6382: else
6383: {
6384: s_copie_variable_partagee = NULL;
6385: }
6386:
6387: if (pthread_mutex_unlock(
6388: &((*(*s_etat_processus)
6389: .pointeur_variable_partagee_courante
6390: ).mutex)) != 0)
6391: {
6392: (*s_etat_processus).erreur_systeme =
6393: d_es_processus;
6394: return(d_erreur);
6395: }
6396: }
6397: else
6398: {
6399: (*s_etat_processus).erreur_systeme = d_es;
6400: presence_variable = d_faux;
6401: presence_variable_partagee = d_faux;
6402: }
6403: }
6404: else
6405: {
6406: presence_variable = d_vrai;
6407:
6408: if ((*(*(*s_etat_processus)
6409: .pointeur_variable_courante).objet)
6410: .type == ADR)
6411: {
6412: presence_fonction = d_vrai;
6413: }
6414: }
6415: }
6416: else
6417: {
6418: presence_variable = d_faux;
6419: }
6420: }
6421:
6422: liberation(s_etat_processus, s_objet_elementaire);
6423:
6424: if (presence_fonction == d_vrai)
6425: {
6426: if ((*((struct_nom *) (*(*l_element_courant).donnee)
6427: .objet)).symbole == d_vrai)
6428: {
6429: // L'objet apparaît comme un symbole dans
6430: // l'expression en cours d'évaluation. On se
6431: // contente de l'empiler.
6432:
6433: if ((s_sous_objet = copie_objet(s_etat_processus,
6434: (*l_element_courant).donnee, 'P')) == NULL)
6435: {
6436: (*s_etat_processus).instruction_courante =
6437: instruction_courante;
6438:
6439: (*s_etat_processus).erreur_systeme =
6440: d_es_allocation_memoire;
6441: return(d_erreur);
6442: }
6443:
6444: if (empilement(s_etat_processus,
6445: &((*s_etat_processus).l_base_pile),
6446: s_sous_objet) == d_erreur)
6447: {
6448: (*s_etat_processus).instruction_courante =
6449: instruction_courante;
6450: liberation(s_etat_processus, s_sous_objet);
6451: return(d_erreur);
6452: }
6453: }
6454: else
6455: {
6456: autorisation_empilement_programme =
6457: (*s_etat_processus)
6458: .autorisation_empilement_programme;
6459: registre_position_courante = (*s_etat_processus)
6460: .position_courante;
6461:
6462: empilement_pile_systeme(s_etat_processus);
6463:
6464: if ((*s_etat_processus).erreur_systeme != d_es)
6465: {
6466: if (presence_variable_partagee == d_vrai)
6467: {
6468: liberation(s_etat_processus,
6469: s_copie_variable_partagee);
6470: }
6471:
6472: if (presence_egalite == d_vrai)
6473: {
6474: liberation(s_etat_processus,
6475: s_objet_evalue);
6476: }
6477:
6478: (*s_etat_processus).instruction_courante =
6479: instruction_courante;
6480: return(d_erreur);
6481: }
6482:
6483: (*(*s_etat_processus).l_base_pile_systeme)
6484: .retour_definition = 'Y';
6485: (*(*s_etat_processus).l_base_pile_systeme)
6486: .origine_routine_evaluation = 'Y';
6487:
6488: (*s_etat_processus).mode_execution_programme = 'Y';
6489: (*s_etat_processus)
6490: .autorisation_empilement_programme = 'N';
6491:
6492: (*(*s_etat_processus).l_base_pile_systeme)
6493: .niveau_courant = (*s_etat_processus)
6494: .niveau_courant;
6495:
6496: if (presence_variable_partagee == d_faux)
6497: {
6498: (*s_etat_processus).position_courante =
6499: (*((integer8 *)
6500: ((*(*(*s_etat_processus)
6501: .pointeur_variable_courante)
6502: .objet).objet)));
6503: }
6504: else
6505: {
6506: (*s_etat_processus).position_courante =
6507: (*((integer8 *)
6508: (*s_copie_variable_partagee).objet));
6509: liberation(s_etat_processus,
6510: s_copie_variable_partagee);
6511: }
6512:
6513: if ((*s_etat_processus).profilage == d_vrai)
6514: {
6515: profilage(s_etat_processus,
6516: (*(*s_etat_processus)
6517: .pointeur_variable_courante).nom);
6518:
6519: if ((*s_etat_processus).erreur_systeme != d_es)
6520: {
6521: return(d_erreur);
6522: }
6523: }
6524:
6525: registre_evaluation_forcee =
6526: (*s_etat_processus).evaluation_forcee;
6527:
6528: if (type_evaluation == 'N')
6529: {
6530: (*s_etat_processus).evaluation_forcee = 'Y';
6531: }
6532:
6533: if (sequenceur(s_etat_processus) == d_erreur)
6534: {
6535: (*s_etat_processus).evaluation_forcee =
6536: registre_evaluation_forcee;
6537:
6538: if (presence_egalite == d_vrai)
6539: {
6540: liberation(s_etat_processus,
6541: s_objet_evalue);
6542: }
6543:
6544: depilement_pile_systeme(s_etat_processus);
6545:
6546: (*s_etat_processus).instruction_courante =
6547: instruction_courante;
6548: (*s_etat_processus).mode_execution_programme =
6549: registre_mode_execution_programme;
6550: return(d_erreur);
6551: }
6552:
6553: (*s_etat_processus).evaluation_forcee =
6554: registre_evaluation_forcee;
6555: (*s_etat_processus).instruction_courante =
6556: instruction_courante;
6557: (*s_etat_processus).mode_execution_programme = 'N';
6558:
6559: depilement_pile_systeme(s_etat_processus);
6560:
6561: if ((*s_etat_processus).erreur_systeme != d_es)
6562: {
6563: if (presence_egalite == d_vrai)
6564: {
6565: liberation(s_etat_processus,
6566: s_objet_evalue);
6567: }
6568:
6569: return(d_erreur);
6570: }
6571:
6572: (*s_etat_processus).retour_routine_evaluation = 'N';
6573: (*s_etat_processus).position_courante =
6574: registre_position_courante;
6575: (*s_etat_processus)
6576: .autorisation_empilement_programme =
6577: autorisation_empilement_programme;
6578: }
6579: }
6580: else if (((type_evaluation == 'N') || ((*((struct_nom *)
6581: (*(*l_element_courant).donnee).objet)).symbole ==
6582: d_faux)) && (presence_variable == d_vrai))
6583: {
6584: if (type_evaluation == 'I')
6585: {
6586: if (presence_variable_partagee == d_faux)
6587: {
6588: if ((s_sous_objet =
6589: copie_objet(s_etat_processus,
6590: (*(*s_etat_processus)
6591: .pointeur_variable_courante).objet,
6592: 'P')) == NULL)
6593: {
6594: if (presence_variable_partagee == d_vrai)
6595: {
6596: liberation(s_etat_processus,
6597: s_copie_variable_partagee);
6598: }
6599:
6600: if (presence_egalite == d_vrai)
6601: {
6602: liberation(s_etat_processus,
6603: s_objet_evalue);
6604: }
6605:
6606: (*s_etat_processus).erreur_systeme =
6607: d_es_allocation_memoire;
6608: (*s_etat_processus).instruction_courante =
6609: instruction_courante;
6610: return(d_erreur);
6611: }
6612:
6613: if (empilement(s_etat_processus,
6614: &((*s_etat_processus).l_base_pile),
6615: s_sous_objet) == d_erreur)
6616: {
6617: if (presence_variable_partagee == d_vrai)
6618: {
6619: liberation(s_etat_processus,
6620: s_copie_variable_partagee);
6621: }
6622:
6623: if (presence_egalite == d_vrai)
6624: {
6625: liberation(s_etat_processus,
6626: s_objet_evalue);
6627: }
6628:
6629: return(d_erreur);
6630: }
6631: }
6632: else
6633: {
6634: if (empilement(s_etat_processus,
6635: &((*s_etat_processus).l_base_pile),
6636: s_copie_variable_partagee) == d_erreur)
6637: {
6638: if (presence_variable_partagee == d_vrai)
6639: {
6640: liberation(s_etat_processus,
6641: s_copie_variable_partagee);
6642: }
6643:
6644: if (presence_egalite == d_vrai)
6645: {
6646: liberation(s_etat_processus,
6647: s_objet_evalue);
6648: }
6649:
6650: return(d_erreur);
6651: }
6652: }
6653: }
6654: else
6655: {
6656: registre_evaluation_expression_compilee =
6657: (*s_etat_processus)
6658: .evaluation_expression_compilee;
6659:
6660: if (((*(*s_etat_processus)
6661: .pointeur_variable_courante)
6662: .origine == 'E') && ((*(*s_etat_processus)
6663: .pointeur_variable_courante).niveau == 0))
6664: {
6665: (*s_etat_processus)
6666: .evaluation_expression_compilee = 'Y';
6667: }
6668: else
6669: {
6670: (*s_etat_processus)
6671: .evaluation_expression_compilee = 'N';
6672: }
6673:
6674: if (presence_variable_partagee == d_faux)
6675: {
6676: if ((*s_etat_processus).profilage == d_vrai)
6677: {
6678: profilage(s_etat_processus,
6679: (*(*s_etat_processus)
6680: .pointeur_variable_courante).nom);
6681:
6682: if ((*s_etat_processus).erreur_systeme
6683: != d_es)
6684: {
6685: return(d_erreur);
6686: }
6687: }
6688:
6689: empilement_pile_systeme(s_etat_processus);
6690:
6691: (*(*s_etat_processus).l_base_pile_systeme)
6692: .retour_definition = 'Y';
6693: (*(*s_etat_processus).l_base_pile_systeme)
6694: .niveau_courant = (*s_etat_processus)
6695: .niveau_courant;
6696: (*(*s_etat_processus).l_base_pile_systeme)
6697: .pointeur_objet_retour =
6698: l_element_courant;
6699: (*(*s_etat_processus).l_base_pile_systeme)
6700: .origine_routine_evaluation = 'Y';
6701:
6702: if (evaluation(s_etat_processus,
6703: (*(*s_etat_processus)
6704: .pointeur_variable_courante).objet,
6705: type_evaluation) == d_erreur)
6706: {
6707: depilement_pile_systeme(s_etat_processus);
6708:
6709: if ((*s_etat_processus).profilage == d_vrai)
6710: {
6711: profilage(s_etat_processus, NULL);
6712: }
6713:
6714: (*s_etat_processus)
6715: .evaluation_expression_compilee =
6716: registre_evaluation_expression_compilee;
6717:
6718: if (presence_egalite == d_vrai)
6719: {
6720: liberation(s_etat_processus,
6721: s_objet_evalue);
6722: }
6723:
6724: (*s_etat_processus).instruction_courante =
6725: instruction_courante;
6726: (*s_etat_processus).mode_execution_programme
6727: = registre_mode_execution_programme;
6728: return(d_erreur);
6729: }
6730:
6731: depilement_pile_systeme(s_etat_processus);
6732: }
6733: else
6734: {
6735: if ((*s_etat_processus).profilage == d_vrai)
6736: {
6737: profilage(s_etat_processus,
6738: (*(*s_etat_processus)
6739: .pointeur_variable_courante).nom);
6740:
6741: if ((*s_etat_processus).erreur_systeme
6742: != d_es)
6743: {
6744: return(d_erreur);
6745: }
6746: }
6747:
6748: empilement_pile_systeme(s_etat_processus);
6749: (*(*s_etat_processus).l_base_pile_systeme)
6750: .retour_definition = 'Y';
6751: (*(*s_etat_processus).l_base_pile_systeme)
6752: .niveau_courant = (*s_etat_processus)
6753: .niveau_courant;
6754:
6755: if (evaluation(s_etat_processus,
6756: s_copie_variable_partagee,
6757: type_evaluation) == d_erreur)
6758: {
6759: depilement_pile_systeme(s_etat_processus);
6760:
6761: liberation(s_etat_processus,
6762: s_copie_variable_partagee);
6763:
6764: if ((*s_etat_processus).profilage == d_vrai)
6765: {
6766: profilage(s_etat_processus, NULL);
6767: }
6768:
6769: (*s_etat_processus)
6770: .evaluation_expression_compilee =
6771: registre_evaluation_expression_compilee;
6772:
6773: if (presence_egalite == d_vrai)
6774: {
6775: liberation(s_etat_processus,
6776: s_objet_evalue);
6777: }
6778:
6779: (*s_etat_processus).instruction_courante =
6780: instruction_courante;
6781: (*s_etat_processus).mode_execution_programme
6782: = registre_mode_execution_programme;
6783: return(d_erreur);
6784: }
6785:
6786: depilement_pile_systeme(s_etat_processus);
6787:
6788: liberation(s_etat_processus,
6789: s_copie_variable_partagee);
6790: }
6791:
6792: if ((*s_etat_processus).profilage == d_vrai)
6793: {
6794: profilage(s_etat_processus, NULL);
6795: }
6796:
6797: (*s_etat_processus)
6798: .evaluation_expression_compilee =
6799: registre_evaluation_expression_compilee;
6800: }
6801: }
6802: else
6803: {
6804: if (presence_variable_partagee == d_vrai)
6805: {
6806: liberation(s_etat_processus,
6807: s_copie_variable_partagee);
6808: }
6809:
6810: if ((s_objet_elementaire =
6811: copie_objet(s_etat_processus,
6812: (*l_element_courant).donnee, 'P')) == NULL)
6813: {
6814: if (presence_egalite == d_vrai)
6815: {
6816: liberation(s_etat_processus, s_objet_evalue);
6817: }
6818:
6819: (*s_etat_processus).erreur_systeme =
6820: d_es_allocation_memoire;
6821: (*s_etat_processus).instruction_courante =
6822: instruction_courante;
6823: return(d_erreur);
6824: }
6825:
6826: /*
6827: * Vérification du drapeau symbole pour
6828: * savoir si l'on met dans la pile le nom
6829: * ou le contenu de la variable.
6830: */
6831:
6832: if (((*((struct_nom *) (*s_objet_elementaire).objet))
6833: .symbole == d_faux) && ((*s_etat_processus)
6834: .traitement_symbolique == 'N'))
6835: {
6836: if (recherche_variable(s_etat_processus,
6837: (*((struct_nom *) (*s_objet_elementaire)
6838: .objet)).nom) == d_vrai)
6839: {
6840: if ((*(*s_etat_processus)
6841: .pointeur_variable_courante).objet
6842: == NULL)
6843: {
6844: // Variable partagée
6845:
6846: if (recherche_variable_partagee(
6847: s_etat_processus,
6848: (*(*s_etat_processus)
6849: .pointeur_variable_courante).nom,
6850: (*(*s_etat_processus)
6851: .pointeur_variable_courante)
6852: .variable_partagee, 'E') != NULL)
6853: {
6854: liberation(s_etat_processus,
6855: s_objet_elementaire);
6856:
6857: if ((s_objet_elementaire =
6858: copie_objet(s_etat_processus,
6859: (*(*s_etat_processus)
6860: .pointeur_variable_partagee_courante
6861: ).objet, 'P')) == NULL)
6862: {
6863: if (pthread_mutex_unlock(
6864: &((*(*s_etat_processus)
6865: .pointeur_variable_partagee_courante
6866: ).mutex)) != 0)
6867: {
6868: (*s_etat_processus)
6869: .erreur_systeme =
6870: d_es_processus;
6871: return(d_erreur);
6872: }
6873:
6874: if (presence_egalite == d_vrai)
6875: {
6876: liberation(s_etat_processus,
6877: s_objet_evalue);
6878: }
6879:
6880: (*s_etat_processus).erreur_systeme =
6881: d_es_allocation_memoire;
6882: (*s_etat_processus)
6883: .instruction_courante =
6884: instruction_courante;
6885: return(d_erreur);
6886: }
6887:
6888: if (pthread_mutex_unlock(
6889: &((*(*s_etat_processus)
6890: .pointeur_variable_partagee_courante
6891: ).mutex)) != 0)
6892: {
6893: (*s_etat_processus).erreur_systeme =
6894: d_es_processus;
6895: return(d_erreur);
6896: }
6897: }
6898: }
6899: else
6900: {
6901: // Variable privée
6902:
6903: liberation(s_etat_processus,
6904: s_objet_elementaire);
6905:
6906: if ((s_objet_elementaire =
6907: copie_objet(s_etat_processus,
6908: (*(*s_etat_processus)
6909: .pointeur_variable_courante).objet,
6910: 'P')) == NULL)
6911: {
6912: if (presence_egalite == d_vrai)
6913: {
6914: liberation(s_etat_processus,
6915: s_objet_evalue);
6916: }
6917:
6918: (*s_etat_processus).erreur_systeme =
6919: d_es_allocation_memoire;
6920: (*s_etat_processus)
6921: .instruction_courante =
6922: instruction_courante;
6923: return(d_erreur);
6924: }
6925: }
6926: }
6927: else
6928: {
6929: (*s_etat_processus).erreur_systeme = d_es;
6930:
6931: (*((struct_nom *) (*s_objet_elementaire)
6932: .objet)).symbole = d_vrai;
6933: }
6934: }
6935:
6936: if (empilement(s_etat_processus, &((*s_etat_processus)
6937: .l_base_pile), s_objet_elementaire) == d_erreur)
6938: {
6939: if (presence_egalite == d_vrai)
6940: {
6941: liberation(s_etat_processus, s_objet_evalue);
6942: }
6943:
6944: (*s_etat_processus).instruction_courante =
6945: instruction_courante;
6946: return(d_erreur);
6947: }
6948:
6949: if ((*s_etat_processus).erreur_execution ==
6950: d_ex_variable_non_definie)
6951: {
6952: (*s_etat_processus).erreur_execution = d_ex;
6953: }
6954: }
6955: }
6956: else
6957: {
6958: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
6959: == d_vrai) ? 'E' : 'N';
6960:
6961: if (type_evaluation == 'N')
6962: {
6963: cf(s_etat_processus, 35);
6964: }
6965: else
6966: {
6967: sf(s_etat_processus, 35);
6968: }
6969:
6970: analyse(s_etat_processus, NULL);
6971:
6972: if (registre_type_evaluation == 'E')
6973: {
6974: sf(s_etat_processus, 35);
6975: }
6976: else
6977: {
6978: cf(s_etat_processus, 35);
6979: }
6980:
6981: if (((*s_etat_processus).erreur_systeme != d_es) ||
6982: ((*s_etat_processus).erreur_execution != d_ex) ||
6983: ((*s_etat_processus).exception != d_ep))
6984: {
6985: // Il est anormal de récupérer ici une erreur
6986: // d'exécution puisqu'on empile une constante
6987: // symbolique.
6988:
6989: if (presence_egalite == d_vrai)
6990: {
6991: liberation(s_etat_processus, s_objet_evalue);
6992: }
6993:
6994: (*s_etat_processus).instruction_courante =
6995: instruction_courante;
6996: (*s_etat_processus).mode_execution_programme =
6997: registre_mode_execution_programme;
6998: return(d_erreur);
6999: }
7000: }
7001:
7002: (*s_etat_processus).instruction_courante =
7003: instruction_courante;
7004: (*s_etat_processus).test_instruction = registre_test;
7005: (*s_etat_processus).instruction_valide =
7006: registre_instruction_valide;
7007: }
7008: else
7009: {
7010: if ((s_objet_tampon = copie_objet(s_etat_processus,
7011: (*l_element_courant).donnee, 'P')) == NULL)
7012: {
7013: (*s_etat_processus).erreur_systeme =
7014: d_es_allocation_memoire;
7015: (*s_etat_processus).instruction_courante =
7016: instruction_courante;
7017: return(d_erreur);
7018: }
7019:
7020: if (empilement(s_etat_processus, &((*s_etat_processus)
7021: .l_base_pile), s_objet_tampon) == d_erreur)
7022: {
7023: if (presence_egalite == d_vrai)
7024: {
7025: liberation(s_etat_processus, s_objet_evalue);
7026: }
7027:
7028: (*s_etat_processus).instruction_courante =
7029: instruction_courante;
7030: return(d_erreur);
7031: }
7032: }
7033:
7034: // Traitement de l'instruction EXIT en mode interactif
7035:
7036: if ((*s_etat_processus).traitement_cycle_exit != 'N')
7037: {
7038: registre_expression_courante =
7039: (*s_etat_processus).expression_courante;
7040: (*s_etat_processus).expression_courante =
7041: l_element_courant;
7042:
7043: switch((*s_etat_processus).traitement_cycle_exit)
7044: {
7045: case 'C' :
7046: {
7047: instruction_cycle(s_etat_processus);
7048: break;
7049: }
7050:
7051: case 'E' :
7052: {
7053: instruction_exit(s_etat_processus);
7054: break;
7055: }
7056: }
7057:
7058: l_element_courant = (*s_etat_processus).expression_courante;
7059: (*s_etat_processus).expression_courante =
7060: registre_expression_courante;
7061: }
7062:
7063: if (l_element_courant != NULL)
7064: {
7065: l_element_courant = (*l_element_courant).suivant;
7066: }
7067: else
7068: {
7069: (*s_etat_processus).mode_execution_programme = 'Y';
7070:
7071: if ((*s_etat_processus).niveau_courant == 1)
7072: {
7073: (*s_etat_processus).debug_programme = d_faux;
7074: (*s_etat_processus).execution_pas_suivant = d_vrai;
7075: }
7076: }
7077:
7078: }
7079:
7080: if (niveau_initial < (*s_etat_processus).niveau_courant)
7081: {
7082: /*
7083: * Retrait des variables dans le cas où l'évaluation de
7084: * l'expression a été interrompue
7085: */
7086:
7087: (*s_etat_processus).niveau_courant = niveau_initial;
7088:
7089: if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
7090: {
7091: if (presence_egalite == d_vrai)
7092: {
7093: liberation(s_etat_processus, s_objet_evalue);
7094: }
7095:
7096: (*s_etat_processus).instruction_courante =
7097: instruction_courante;
7098: (*s_etat_processus).mode_execution_programme =
7099: registre_mode_execution_programme;
7100: return(d_erreur);
7101: }
7102: }
7103:
7104: /*
7105: * Retrait des variables statiques créées dans l'expression
7106: */
7107:
7108: if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur)
7109: {
7110: if (presence_egalite == d_vrai)
7111: {
7112: liberation(s_etat_processus, s_objet_evalue);
7113: }
7114:
7115: (*s_etat_processus).instruction_courante =
7116: instruction_courante;
7117: (*s_etat_processus).mode_execution_programme =
7118: registre_mode_execution_programme;
7119: return(d_erreur);
7120: }
7121:
7122: /*
7123: * Retrait des variables partagées créées dans l'expression
7124: */
7125:
7126: if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur)
7127: {
7128: if (presence_egalite == d_vrai)
7129: {
7130: liberation(s_etat_processus, s_objet_evalue);
7131: }
7132:
7133: (*s_etat_processus).instruction_courante =
7134: instruction_courante;
7135: (*s_etat_processus).mode_execution_programme =
7136: registre_mode_execution_programme;
7137: return(d_erreur);
7138: }
7139:
7140: if ((*s_etat_processus).var_volatile_requete_arret != 0)
7141: {
7142: // Restauration de la pile système
7143:
7144: while(pile_systeme_originelle !=
7145: (*s_etat_processus).l_base_pile_systeme)
7146: {
7147: depilement_pile_systeme(s_etat_processus);
7148: }
7149: }
7150:
7151: if (presence_egalite == d_vrai)
7152: {
7153: // Ajout du membre évalué lors de la première passe
7154:
7155: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
7156: s_objet_evalue) == d_erreur)
7157: {
7158: (*s_etat_processus).instruction_courante =
7159: instruction_courante;
7160: return(d_erreur);
7161: }
7162:
7163: instruction_swap(s_etat_processus);
7164:
7165: if ((*s_etat_processus).erreur_execution != d_ex)
7166: {
7167: (*s_etat_processus).mode_execution_programme =
7168: registre_mode_execution_programme;
7169: (*s_etat_processus).autorisation_empilement_programme =
7170: autorisation_empilement_programme;
7171: (*s_etat_processus).instruction_courante = instruction_courante;
7172: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
7173: registre_retour_definition;
7174:
7175: return(d_erreur);
7176: }
7177:
7178: instruction_egalite(s_etat_processus);
7179:
7180: if ((*s_etat_processus).erreur_execution != d_ex)
7181: {
7182: (*s_etat_processus).mode_execution_programme =
7183: registre_mode_execution_programme;
7184: (*s_etat_processus).autorisation_empilement_programme =
7185: autorisation_empilement_programme;
7186: (*s_etat_processus).instruction_courante = instruction_courante;
7187: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
7188: registre_retour_definition;
7189:
7190: return(d_erreur);
7191: }
7192: }
7193:
7194: (*s_etat_processus).autorisation_empilement_programme =
7195: autorisation_empilement_programme;
7196: (*s_etat_processus).instruction_courante = instruction_courante;
7197: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
7198: registre_retour_definition;
7199: }
7200: else if ((*s_objet).type == FCT)
7201: {
7202: (*s_etat_processus).instruction_courante =
7203: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
7204:
7205: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
7206: ? 'E' : 'N';
7207: cf(s_etat_processus, 35);
7208:
7209: analyse(s_etat_processus, (*((struct_fonction *)
7210: (*s_objet).objet)).fonction);
7211: (*s_etat_processus).instruction_courante = instruction_courante;
7212:
7213: if (registre_type_evaluation == 'E')
7214: {
7215: sf(s_etat_processus, 35);
7216: }
7217: else
7218: {
7219: cf(s_etat_processus, 35);
7220: }
7221:
7222: if (((*s_etat_processus).erreur_systeme != d_es) ||
7223: ((*s_etat_processus).erreur_execution != d_ex) ||
7224: ((*s_etat_processus).exception != d_ep))
7225: {
7226: (*s_etat_processus).mode_execution_programme =
7227: registre_mode_execution_programme;
7228: return(d_erreur);
7229: }
7230: }
7231: else
7232: {
7233: (*s_etat_processus).instruction_courante = instruction_courante;
7234:
7235: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
7236: == NULL)
7237: {
7238: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
7239: return(d_erreur);
7240: }
7241:
7242: if (empilement(s_etat_processus, &((*s_etat_processus)
7243: .l_base_pile), s_objet_tampon) == d_erreur)
7244: {
7245: return(d_erreur);
7246: }
7247: }
7248:
7249: (*s_etat_processus).mode_execution_programme =
7250: registre_mode_execution_programme;
7251:
7252: return((erreur_evaluation == d_absence_erreur)
7253: ? d_absence_erreur : d_erreur);
7254: }
7255:
7256: // vim: ts=4