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