![[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 |
1.1 bertrand 1: /*
2: ================================================================================
1.55 bertrand 3: RPL/2 (R) version 4.1.10
1.50 bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 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:
1.12 bertrand 22:
1.24 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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;
1.57 ! bertrand 54: logical1 presence_compteur;
1.1 bertrand 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;
1.4 bertrand 84: unsigned char registre_evaluation_forcee;
1.1 bertrand 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: {
1.12 bertrand 144: (*s_etat_processus).erreur_execution = d_ex;
145:
1.9 bertrand 146: if ((*s_etat_processus).autorisation_nom_implicite == 'N')
147: {
148: if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
149: d_faux)
150: {
1.12 bertrand 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;
1.9 bertrand 161: (*s_etat_processus).erreur_execution =
1.11 bertrand 162: d_ex_nom_implicite;
1.12 bertrand 163:
164: if (type_evaluation == 'I')
165: {
166: (*s_etat_processus).derniere_erreur_evaluation =
167: (*s_etat_processus).erreur_execution;
168: }
1.9 bertrand 169: }
170: }
171:
1.1 bertrand 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: {
1.34 bertrand 179: if ((*(*s_etat_processus).pointeur_variable_courante)
1.1 bertrand 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,
1.34 bertrand 195: (*(*s_etat_processus)
196: .pointeur_variable_courante).nom,
197: (*(*s_etat_processus)
198: .pointeur_variable_courante)
1.1 bertrand 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:
1.34 bertrand 267: if ((*(*(*s_etat_processus).pointeur_variable_courante)
268: .objet).type == ADR)
1.1 bertrand 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 *)
1.34 bertrand 319: ((*(*(*s_etat_processus).pointeur_variable_courante)
320: .objet).objet)));
1.1 bertrand 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,
1.34 bertrand 341: (*(*s_etat_processus).pointeur_variable_courante)
1.1 bertrand 342: .nom);
343:
344: if ((*s_etat_processus).erreur_systeme != d_es)
345: {
346: return(d_erreur);
347: }
348: }
349:
1.4 bertrand 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:
1.1 bertrand 358: if (sequenceur(s_etat_processus) == d_erreur)
359: {
1.4 bertrand 360: (*s_etat_processus).evaluation_forcee =
361: registre_evaluation_forcee;
1.1 bertrand 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:
1.4 bertrand 369: (*s_etat_processus).evaluation_forcee =
370: registre_evaluation_forcee;
1.1 bertrand 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:
1.34 bertrand 393: if (((*(*s_etat_processus).pointeur_variable_courante).origine
394: == 'E') && ((*(*s_etat_processus)
395: .pointeur_variable_courante).niveau == 0))
1.1 bertrand 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,
1.34 bertrand 407: (*(*s_etat_processus).pointeur_variable_courante)
1.1 bertrand 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:
1.19 bertrand 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:
1.1 bertrand 458: if (presence_variable_partagee == d_faux)
459: {
1.34 bertrand 460: if (evaluation(s_etat_processus, (*(*s_etat_processus)
461: .pointeur_variable_courante).objet,
1.1 bertrand 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:
1.19 bertrand 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:
1.1 bertrand 517: (*s_etat_processus).evaluation_expression_compilee =
518: registre_evaluation_expression_compilee;
1.19 bertrand 519: (*s_etat_processus).autorisation_empilement_programme =
520: autorisation_empilement_programme;
1.1 bertrand 521: }
1.12 bertrand 522: else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
1.1 bertrand 523: {
524: if ((s_objet_tampon = copie_objet(s_etat_processus,
1.12 bertrand 525: s_objet, 'Q')) == NULL)
1.1 bertrand 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';
1.22 bertrand 761: (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour =
762: s_objet;
1.1 bertrand 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: {
1.47 bertrand 826: envoi_signal_processus((*s_etat_processus)
827: .pid_processus_pere, rpl_sigalrm);
1.1 bertrand 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:
1.16 bertrand 862: drapeau_then = d_faux;
863:
864: while(drapeau_then == d_faux)
1.1 bertrand 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) ||
1.57 ! bertrand 916: TEST(instruction_forall) ||
1.1 bertrand 917: TEST(instruction_start) ||
918: TEST(instruction_select) ||
919: TEST(instruction_case) ||
1.56 bertrand 920: TEST(instruction_critical) ||
1.1 bertrand 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:
1.2 bertrand 935: if ((*s_etat_processus)
936: .erreur_systeme != d_es)
937: {
1.56 bertrand 938: if (presence_egalite ==
939: d_vrai)
940: {
941: liberation(
942: s_etat_processus,
943: s_objet_evalue);
944: }
945:
1.2 bertrand 946: (*s_etat_processus)
947: .instruction_courante =
948: instruction_courante;
949: return(d_erreur);
950: }
951:
1.1 bertrand 952: (*s_etat_processus).exception
953: = registre_exception;
954: (*s_etat_processus)
955: .erreur_execution =
956: registre_erreur_execution;
957: }
1.57 ! bertrand 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: }
1.1 bertrand 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:
1.2 bertrand 1025: if ((*s_etat_processus)
1026: .erreur_systeme != d_es)
1027: {
1.56 bertrand 1028: if (presence_egalite ==
1029: d_vrai)
1030: {
1031: liberation(
1032: s_etat_processus,
1033: s_objet_evalue);
1034: }
1035:
1.2 bertrand 1036: (*s_etat_processus)
1037: .instruction_courante =
1038: instruction_courante;
1039: return(d_erreur);
1040: }
1041:
1.1 bertrand 1042: (*s_etat_processus).exception
1043: = registre_exception;
1044: (*s_etat_processus)
1045: .erreur_execution =
1046: registre_erreur_execution;
1047: }
1.57 ! bertrand 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: }
1.1 bertrand 1168: else
1169: {
1.56 bertrand 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: }
1.57 ! bertrand 1217:
! 1218: (*s_etat_processus)
! 1219: .sections_critiques--;
1.56 bertrand 1220: }
1221:
1.1 bertrand 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: }
1.16 bertrand 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: }
1.1 bertrand 1257: }
1258: }
1259: }
1260:
1.16 bertrand 1261: (*s_etat_processus).expression_courante =
1262: l_element_courant;
1.1 bertrand 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) ||
1.57 ! bertrand 1305: TEST(instruction_forall) ||
1.1 bertrand 1306: TEST(instruction_start) ||
1307: TEST(instruction_select) ||
1308: TEST(instruction_case) ||
1.56 bertrand 1309: TEST(instruction_critical) ||
1.1 bertrand 1310: TEST(vers_niveau_superieur))
1311: {
1312: if (TEST(vers_niveau_superieur))
1313: {
1314: analyse(s_etat_processus,
1315: vers_niveau_superieur);
1.2 bertrand 1316:
1317: if ((*s_etat_processus)
1318: .erreur_systeme != d_es)
1319: {
1.56 bertrand 1320: if (presence_egalite ==
1321: d_vrai)
1322: {
1323: liberation(
1324: s_etat_processus,
1325: s_objet_evalue);
1326: }
1327:
1.2 bertrand 1328: (*s_etat_processus)
1329: .instruction_courante =
1330: instruction_courante;
1331: return(d_erreur);
1332: }
1.1 bertrand 1333: }
1.57 ! bertrand 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: }
1.1 bertrand 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);
1.2 bertrand 1393:
1394: if ((*s_etat_processus)
1395: .erreur_systeme != d_es)
1396: {
1.56 bertrand 1397: if (presence_egalite ==
1398: d_vrai)
1399: {
1400: liberation(
1401: s_etat_processus,
1402: s_objet_evalue);
1403: }
1404:
1.2 bertrand 1405: (*s_etat_processus)
1406: .instruction_courante =
1407: instruction_courante;
1408: return(d_erreur);
1409: }
1.1 bertrand 1410: }
1.57 ! bertrand 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: }
1.1 bertrand 1531: else
1532: {
1.56 bertrand 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:
1.1 bertrand 1589: depilement_pile_systeme(
1590: s_etat_processus);
1.21 bertrand 1591: }
1.1 bertrand 1592:
1.21 bertrand 1593: if ((*s_etat_processus)
1594: .erreur_systeme != d_es)
1595: {
1596: if (presence_egalite ==
1597: d_vrai)
1.1 bertrand 1598: {
1.21 bertrand 1599: liberation(
1600: s_etat_processus,
1601: s_objet_evalue);
1602: }
1.1 bertrand 1603:
1.21 bertrand 1604: (*s_etat_processus)
1605: .instruction_courante =
1606: instruction_courante;
1607: return(d_erreur);
1.1 bertrand 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) ||
1.57 ! bertrand 1679: TEST(instruction_forall) ||
1.1 bertrand 1680: TEST(instruction_start) ||
1681: TEST(instruction_select) ||
1682: TEST(instruction_case) ||
1.56 bertrand 1683: TEST(instruction_critical) ||
1.1 bertrand 1684: TEST(vers_niveau_superieur))
1685: {
1686: if (TEST(vers_niveau_superieur))
1687: {
1688: analyse(s_etat_processus,
1689: vers_niveau_superieur);
1.2 bertrand 1690:
1691: if ((*s_etat_processus)
1692: .erreur_systeme != d_es)
1693: {
1.56 bertrand 1694: if (presence_egalite ==
1695: d_vrai)
1696: {
1697: liberation(
1698: s_etat_processus,
1699: s_objet_evalue);
1700: }
1701:
1.2 bertrand 1702: (*s_etat_processus)
1703: .instruction_courante =
1704: instruction_courante;
1705: return(d_erreur);
1706: }
1.1 bertrand 1707: }
1.57 ! bertrand 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: }
1.1 bertrand 1735: else
1736: {
1737: empilement_pile_systeme(
1738: s_etat_processus);
1739:
1740: if ((*s_etat_processus)
1.57 ! bertrand 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(
1.1 bertrand 1877: s_etat_processus,
1878: s_objet_evalue);
1.57 ! bertrand 1879: }
! 1880:
! 1881: (*s_etat_processus)
! 1882: .instruction_courante =
! 1883: instruction_courante;
! 1884: return(d_erreur);
1.1 bertrand 1885: }
1886:
1887: (*s_etat_processus)
1.57 ! bertrand 1888: .niveau_courant--;
1.2 bertrand 1889:
1.57 ! bertrand 1890: if (
! 1891: retrait_variable_par_niveau(
! 1892: s_etat_processus) ==
! 1893: d_erreur)
1.56 bertrand 1894: {
1.57 ! bertrand 1895: if (presence_egalite ==
! 1896: d_vrai)
! 1897: {
! 1898: liberation(
1.56 bertrand 1899: s_etat_processus,
1900: s_objet_evalue);
1.57 ! bertrand 1901: }
1.56 bertrand 1902:
1.57 ! bertrand 1903: (*s_etat_processus)
1.2 bertrand 1904: .instruction_courante =
1905: instruction_courante;
1.57 ! bertrand 1906: return(d_erreur);
! 1907: }
1.2 bertrand 1908: }
1.15 bertrand 1909:
1.57 ! bertrand 1910: depilement_pile_systeme(
! 1911: s_etat_processus);
1.1 bertrand 1912: }
1913: else
1914: {
1.56 bertrand 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)
1.57 ! bertrand 1935: .instruction_courante =
! 1936: instruction_courante;
1.56 bertrand 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)
1.57 ! bertrand 1961: .instruction_courante =
! 1962: instruction_courante;
1.56 bertrand 1963: return(d_erreur);
1964: }
1965:
1966: (*s_etat_processus)
1967: .sections_critiques--;
1968: }
1969:
1.1 bertrand 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: {
1.47 bertrand 2011: envoi_signal_processus((*s_etat_processus)
2012: .pid_processus_pere, rpl_sigalrm);
1.1 bertrand 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:
1.34 bertrand 2322: if ((*(*s_etat_processus).pointeur_variable_courante).objet
2323: == NULL)
1.1 bertrand 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,
1.34 bertrand 2333: (*(*s_etat_processus)
2334: .pointeur_variable_courante).nom,
2335: (*(*s_etat_processus)
2336: .pointeur_variable_courante).variable_partagee,
2337: 'E') == d_vrai)
1.1 bertrand 2338: {
2339: // Une variable partagée existe.
2340:
2341: presence_variable_partagee = d_vrai;
2342:
1.34 bertrand 2343: (*(*s_etat_processus).pointeur_variable_courante)
2344: .objet = (*(*s_etat_processus)
1.1 bertrand 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:
1.34 bertrand 2371: if ((*(*s_etat_processus).pointeur_variable_courante)
1.1 bertrand 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: {
1.34 bertrand 2384: (*(*s_etat_processus)
2385: .pointeur_variable_courante).objet =
1.1 bertrand 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: }
1.34 bertrand 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))
1.1 bertrand 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: {
1.34 bertrand 2418: (*(*s_etat_processus)
2419: .pointeur_variable_courante).objet =
1.1 bertrand 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:
1.35 bertrand 2445: if ((*s_objet_indice_i).type != INT)
1.1 bertrand 2446: {
2447: liberation(s_etat_processus, s_objet_indice_i);
2448: free(s_objet_elementaire);
2449:
2450: if (presence_variable_partagee == d_vrai)
2451: {
1.34 bertrand 2452: (*(*s_etat_processus)
2453: .pointeur_variable_courante).objet =
1.1 bertrand 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 *)
1.34 bertrand 2484: (*((*(*s_etat_processus)
2485: .pointeur_variable_courante).objet)).objet))
1.1 bertrand 2486: .taille))
2487: {
2488: free(s_objet_elementaire);
2489:
2490: if (presence_variable_partagee == d_vrai)
2491: {
1.34 bertrand 2492: (*(*s_etat_processus)
2493: .pointeur_variable_courante).objet =
1.1 bertrand 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:
1.34 bertrand 2519: if ((*((*(*s_etat_processus)
2520: .pointeur_variable_courante).objet)).type
1.1 bertrand 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: {
1.34 bertrand 2534: (*(*s_etat_processus)
2535: .pointeur_variable_courante).objet =
2536: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2558: (*((*(*s_etat_processus)
2559: .pointeur_variable_courante).objet))
1.1 bertrand 2560: .objet)).tableau)[i - 1];
2561: }
1.34 bertrand 2562: else if ((*((*(*s_etat_processus)
2563: .pointeur_variable_courante).objet)).type
1.1 bertrand 2564: == VRL)
2565: {
2566: if (((*s_objet_elementaire).objet = malloc(sizeof(
2567: real8))) == NULL)
2568: {
2569: if (presence_variable_partagee == d_vrai)
2570: {
1.34 bertrand 2571: (*(*s_etat_processus)
2572: .pointeur_variable_courante).objet =
2573: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2601: (*((*(*s_etat_processus)
2602: .pointeur_variable_courante).objet))
1.1 bertrand 2603: .objet)).tableau)[i - 1];
2604: }
1.34 bertrand 2605: else if ((*((*(*s_etat_processus)
2606: .pointeur_variable_courante).objet)).type
1.1 bertrand 2607: == VCX)
2608: {
2609: if (((*s_objet_elementaire).objet = malloc(sizeof(
2610: struct_complexe16))) == NULL)
2611: {
2612: if (presence_variable_partagee == d_vrai)
2613: {
1.34 bertrand 2614: (*(*s_etat_processus)
2615: .pointeur_variable_courante).objet =
2616: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2645: (*((*(*s_etat_processus)
2646: .pointeur_variable_courante).objet))
2647: .objet)).tableau)[i - 1].partie_reelle;
1.1 bertrand 2648: (*((struct_complexe16 *) (*s_objet_elementaire)
2649: .objet)).partie_imaginaire =
2650: ((struct_complexe16 *) (*((struct_vecteur *)
1.34 bertrand 2651: (*((*(*s_etat_processus)
2652: .pointeur_variable_courante).objet))
2653: .objet)).tableau)[i - 1].partie_imaginaire;
1.1 bertrand 2654: }
2655: }
2656:
2657: /*
2658: * Recherche d'un élément dans une matrice
2659: */
2660:
1.34 bertrand 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))
1.1 bertrand 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: {
1.34 bertrand 2677: (*(*s_etat_processus)
2678: .pointeur_variable_courante).objet =
2679: NULL;
1.1 bertrand 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: {
1.34 bertrand 2713: (*(*s_etat_processus)
2714: .pointeur_variable_courante).objet =
2715: NULL;
1.1 bertrand 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: {
1.34 bertrand 2750: (*(*s_etat_processus)
2751: .pointeur_variable_courante).objet =
2752: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2785: (*((*(*s_etat_processus)
2786: .pointeur_variable_courante).objet)).objet))
1.1 bertrand 2787: .nombre_lignes) || (j < 1) || (j > (integer8)
1.34 bertrand 2788: (*((struct_matrice *) (*((*(*s_etat_processus)
2789: .pointeur_variable_courante).objet)).objet))
1.1 bertrand 2790: .nombre_colonnes))
2791: {
2792: free(s_objet_elementaire);
2793:
2794: if (presence_variable_partagee == d_vrai)
2795: {
1.34 bertrand 2796: (*(*s_etat_processus)
2797: .pointeur_variable_courante).objet =
2798: NULL;
1.1 bertrand 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:
1.34 bertrand 2824: if ((*((*(*s_etat_processus).pointeur_variable_courante)
2825: .objet)).type == MIN)
1.1 bertrand 2826: {
2827: if (((*s_objet_elementaire).objet = malloc(sizeof(
2828: integer8))) == NULL)
2829: {
2830: if (presence_variable_partagee == d_vrai)
2831: {
1.34 bertrand 2832: (*(*s_etat_processus)
2833: .pointeur_variable_courante).objet =
2834: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2862: (*((*(*s_etat_processus)
2863: .pointeur_variable_courante).objet))
1.1 bertrand 2864: .objet)).tableau)[i - 1][j - 1];
2865: }
1.34 bertrand 2866: else if ((*((*(*s_etat_processus)
2867: .pointeur_variable_courante).objet)).type
1.1 bertrand 2868: == MRL)
2869: {
2870: if (((*s_objet_elementaire).objet = malloc(sizeof(
2871: real8))) == NULL)
2872: {
2873: if (presence_variable_partagee == d_vrai)
2874: {
1.34 bertrand 2875: (*(*s_etat_processus)
2876: .pointeur_variable_courante).objet =
2877: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2905: (*((*(*s_etat_processus)
2906: .pointeur_variable_courante).objet))
1.1 bertrand 2907: .objet)).tableau)[i - 1][j - 1];
2908: }
1.34 bertrand 2909: else if ((*((*(*s_etat_processus)
2910: .pointeur_variable_courante).objet)).type
1.1 bertrand 2911: == MCX)
2912: {
2913: if (((*s_objet_elementaire).objet = malloc(sizeof(
2914: struct_complexe16))) == NULL)
2915: {
2916: if (presence_variable_partagee == d_vrai)
2917: {
1.34 bertrand 2918: (*(*s_etat_processus)
2919: .pointeur_variable_courante).objet =
2920: NULL;
1.1 bertrand 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 *)
1.34 bertrand 2950: (*((*(*s_etat_processus)
2951: .pointeur_variable_courante).objet))
1.1 bertrand 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 *)
1.34 bertrand 2958: (*((*(*s_etat_processus)
2959: .pointeur_variable_courante).objet))
1.1 bertrand 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:
1.34 bertrand 2969: else if (((*((*(*s_etat_processus)
2970: .pointeur_variable_courante).objet)).type == LST) &&
1.1 bertrand 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: {
1.34 bertrand 2981: (*(*s_etat_processus)
2982: .pointeur_variable_courante).objet =
2983: NULL;
1.1 bertrand 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: {
1.34 bertrand 3016: (*(*s_etat_processus)
3017: .pointeur_variable_courante).objet =
3018: NULL;
1.1 bertrand 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:
1.34 bertrand 3048: l_sous_element_courant = (*((*(*s_etat_processus)
3049: .pointeur_variable_courante).objet)).objet;
1.1 bertrand 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: {
1.34 bertrand 3069: (*(*s_etat_processus)
3070: .pointeur_variable_courante).objet =
3071: NULL;
1.1 bertrand 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: {
1.34 bertrand 3105: (*(*s_etat_processus)
3106: .pointeur_variable_courante).objet =
3107: NULL;
1.1 bertrand 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:
1.34 bertrand 3136: else if (((*((*(*s_etat_processus)
1.35 bertrand 3137: .pointeur_variable_courante).objet)).type == TBL) &&
1.1 bertrand 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: {
1.34 bertrand 3148: (*(*s_etat_processus)
3149: .pointeur_variable_courante).objet =
3150: NULL;
1.1 bertrand 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: {
1.34 bertrand 3183: (*(*s_etat_processus)
3184: .pointeur_variable_courante).objet =
3185: NULL;
1.1 bertrand 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 *)
1.34 bertrand 3216: (*(*(*s_etat_processus)
3217: .pointeur_variable_courante).objet)
1.1 bertrand 3218: .objet)).nombre_elements))
3219: {
3220: free(s_objet_elementaire);
3221:
3222: if (presence_variable_partagee == d_vrai)
3223: {
1.34 bertrand 3224: (*(*s_etat_processus)
3225: .pointeur_variable_courante).objet =
3226: NULL;
1.1 bertrand 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,
1.34 bertrand 3256: (*((struct_tableau *) (*(*(*s_etat_processus)
3257: .pointeur_variable_courante).objet)
1.1 bertrand 3258: .objet)).elements[i - 1], 'P')) == NULL)
3259: {
3260: if (presence_variable_partagee == d_vrai)
3261: {
1.34 bertrand 3262: (*(*s_etat_processus)
3263: .pointeur_variable_courante).objet =
3264: NULL;
1.1 bertrand 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: }
1.34 bertrand 3288: else if (((*((*(*s_etat_processus)
3289: .pointeur_variable_courante).objet)).type == ALG) ||
3290: ((*((*(*s_etat_processus)
3291: .pointeur_variable_courante).objet)).type == RPN))
1.1 bertrand 3292: {
3293: registre_evaluation_expression_compilee =
3294: (*s_etat_processus)
3295: .evaluation_expression_compilee;
3296:
1.34 bertrand 3297: if (((*(*s_etat_processus).pointeur_variable_courante)
3298: .origine == 'E') && ((*(*s_etat_processus)
3299: .pointeur_variable_courante).niveau == 0))
1.1 bertrand 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:
1.34 bertrand 3310: if (evaluation(s_etat_processus, (*(*s_etat_processus)
3311: .pointeur_variable_courante).objet,
1.1 bertrand 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: {
1.34 bertrand 3319: (*(*s_etat_processus)
3320: .pointeur_variable_courante).objet =
3321: NULL;
1.1 bertrand 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: {
1.34 bertrand 3356: (*(*s_etat_processus)
3357: .pointeur_variable_courante).objet =
3358: NULL;
1.1 bertrand 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: }
1.34 bertrand 3384: else if ((*((*(*s_etat_processus)
3385: .pointeur_variable_courante).objet)).type == ADR)
1.1 bertrand 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: {
1.34 bertrand 3398: (*(*s_etat_processus)
3399: .pointeur_variable_courante).objet =
3400: NULL;
1.1 bertrand 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 *)
1.34 bertrand 3437: ((*(*(*s_etat_processus)
3438: .pointeur_variable_courante).objet).objet)));
1.1 bertrand 3439:
3440: if ((*s_etat_processus).profilage == d_vrai)
3441: {
3442: profilage(s_etat_processus,
1.34 bertrand 3443: (*(*s_etat_processus)
3444: .pointeur_variable_courante).nom);
1.1 bertrand 3445:
3446: if ((*s_etat_processus).erreur_systeme != d_es)
3447: {
3448: if (presence_variable_partagee == d_vrai)
3449: {
1.34 bertrand 3450: (*(*s_etat_processus)
3451: .pointeur_variable_courante).objet =
3452: NULL;
1.1 bertrand 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:
1.4 bertrand 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:
1.1 bertrand 3476: if (sequenceur(s_etat_processus) == d_erreur)
3477: {
1.4 bertrand 3478: (*s_etat_processus).evaluation_forcee =
3479: registre_evaluation_forcee;
3480:
1.1 bertrand 3481: if (presence_variable_partagee == d_vrai)
3482: {
1.34 bertrand 3483: (*(*s_etat_processus)
3484: .pointeur_variable_courante).objet =
3485: NULL;
1.1 bertrand 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:
1.4 bertrand 3508: (*s_etat_processus).evaluation_forcee =
3509: registre_evaluation_forcee;
1.1 bertrand 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: {
1.34 bertrand 3520: (*(*s_etat_processus)
3521: .pointeur_variable_courante).objet =
3522: NULL;
1.1 bertrand 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: {
1.34 bertrand 3555: (*(*s_etat_processus)
3556: .pointeur_variable_courante).objet =
3557: NULL;
1.1 bertrand 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: {
1.34 bertrand 3586: (*(*s_etat_processus)
3587: .pointeur_variable_courante).objet =
3588: NULL;
1.1 bertrand 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: {
1.34 bertrand 3618: (*(*s_etat_processus)
3619: .pointeur_variable_courante).objet =
3620: NULL;
1.1 bertrand 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: {
1.34 bertrand 3642: (*(*s_etat_processus)
3643: .pointeur_variable_courante).objet = NULL;
1.1 bertrand 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:
1.5 bertrand 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:
1.1 bertrand 3785: analyse(s_etat_processus, NULL);
3786:
1.5 bertrand 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:
1.1 bertrand 3796: (*s_etat_processus).test_instruction = registre_test_2;
1.2 bertrand 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: {
1.47 bertrand 3808: envoi_signal_processus((*s_etat_processus)
3809: .pid_processus_pere, rpl_sigalrm);
1.2 bertrand 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) ||
1.57 ! bertrand 3897: TEST(instruction_forall) ||
1.2 bertrand 3898: TEST(instruction_start) ||
3899: TEST(instruction_select) ||
3900: TEST(instruction_case) ||
1.56 bertrand 3901: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 3919: if (presence_egalite ==
3920: d_vrai)
3921: {
3922: liberation(
3923: s_etat_processus,
3924: s_objet_evalue);
3925: }
3926:
1.2 bertrand 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: }
1.57 ! bertrand 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: }
1.2 bertrand 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: {
1.56 bertrand 4009: if (presence_egalite ==
4010: d_vrai)
4011: {
4012: liberation(
4013: s_etat_processus,
4014: s_objet_evalue);
4015: }
4016:
1.2 bertrand 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: }
1.57 ! bertrand 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: }
1.2 bertrand 4149: else
4150: {
1.56 bertrand 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: }
1.57 ! bertrand 4201:
! 4202: (*s_etat_processus)
! 4203: .sections_critiques--;
1.56 bertrand 4204: }
4205:
1.2 bertrand 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) ||
1.57 ! bertrand 4327: TEST(instruction_forall) ||
1.2 bertrand 4328: TEST(instruction_start) ||
4329: TEST(instruction_select) ||
4330: TEST(instruction_case) ||
1.56 bertrand 4331: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 4342: if (presence_egalite ==
4343: d_vrai)
4344: {
4345: liberation(
4346: s_etat_processus,
4347: s_objet_evalue);
4348: }
4349:
1.2 bertrand 4350: (*s_etat_processus)
4351: .instruction_courante =
4352: instruction_courante;
4353: return(d_erreur);
4354: }
4355: }
1.57 ! bertrand 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: }
1.2 bertrand 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:
1.57 ! bertrand 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(
1.56 bertrand 4517: s_etat_processus,
4518: s_objet_evalue);
1.57 ! bertrand 4519: }
! 4520:
! 4521: (*s_etat_processus)
! 4522: .instruction_courante =
! 4523: instruction_courante;
! 4524: return(d_erreur);
1.56 bertrand 4525: }
4526:
1.2 bertrand 4527: (*s_etat_processus)
1.57 ! bertrand 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)
1.2 bertrand 4544: .instruction_courante =
4545: instruction_courante;
1.57 ! bertrand 4546: return(d_erreur);
! 4547: }
1.2 bertrand 4548: }
1.57 ! bertrand 4549:
! 4550: depilement_pile_systeme(
! 4551: s_etat_processus);
1.2 bertrand 4552: }
4553: else
4554: {
1.56 bertrand 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: }
1.57 ! bertrand 4605:
! 4606: (*s_etat_processus)
! 4607: .sections_critiques--;
1.56 bertrand 4608: }
4609:
1.2 bertrand 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) ||
1.57 ! bertrand 4697: TEST(instruction_forall) ||
1.2 bertrand 4698: TEST(instruction_start) ||
4699: TEST(instruction_select) ||
4700: TEST(instruction_case) ||
1.56 bertrand 4701: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 4712: if (presence_egalite ==
4713: d_vrai)
4714: {
4715: liberation(
4716: s_etat_processus,
4717: s_objet_evalue);
4718: }
4719:
1.2 bertrand 4720: (*s_etat_processus)
4721: .instruction_courante =
4722: instruction_courante;
4723: return(d_erreur);
4724: }
4725: }
1.57 ! bertrand 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: }
1.2 bertrand 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: {
1.56 bertrand 4789: if (presence_egalite ==
4790: d_vrai)
4791: {
4792: liberation(
4793: s_etat_processus,
4794: s_objet_evalue);
4795: }
4796:
1.2 bertrand 4797: (*s_etat_processus)
4798: .instruction_courante =
4799: instruction_courante;
4800: return(d_erreur);
4801: }
4802: }
1.57 ! bertrand 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: }
1.2 bertrand 4923: else
4924: {
1.56 bertrand 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: }
1.57 ! bertrand 4975:
! 4976: (*s_etat_processus)
! 4977: .sections_critiques--;
1.56 bertrand 4978: }
4979:
1.2 bertrand 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: {
1.47 bertrand 5021: envoi_signal_processus((*s_etat_processus)
5022: .pid_processus_pere, rpl_sigalrm);
1.2 bertrand 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: {
1.47 bertrand 5049: envoi_signal_processus((*s_etat_processus)
5050: .pid_processus_pere, rpl_sigalrm);
1.2 bertrand 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) ||
1.57 ! bertrand 5138: TEST(instruction_forall) ||
1.2 bertrand 5139: TEST(instruction_start) ||
5140: TEST(instruction_select) ||
5141: TEST(instruction_case) ||
1.56 bertrand 5142: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 5160: if (presence_egalite ==
5161: d_vrai)
5162: {
5163: liberation(
5164: s_etat_processus,
5165: s_objet_evalue);
5166: }
5167:
1.2 bertrand 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: }
1.57 ! bertrand 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: }
1.2 bertrand 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: {
1.56 bertrand 5250: if (presence_egalite ==
5251: d_vrai)
5252: {
5253: liberation(
5254: s_etat_processus,
5255: s_objet_evalue);
5256: }
5257:
1.2 bertrand 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)
1.57 ! bertrand 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);
1.2 bertrand 5389: }
5390: else
5391: {
1.56 bertrand 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: }
1.57 ! bertrand 5442:
! 5443: (*s_etat_processus)
! 5444: .sections_critiques--;
1.56 bertrand 5445: }
5446:
1.2 bertrand 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,
1.11 bertrand 5484: * le séquenceur reprend la main.
1.2 bertrand 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) ||
1.57 ! bertrand 5568: TEST(instruction_forall) ||
1.2 bertrand 5569: TEST(instruction_start) ||
5570: TEST(instruction_select) ||
5571: TEST(instruction_case) ||
1.56 bertrand 5572: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 5583: if (presence_egalite ==
5584: d_vrai)
5585: {
5586: liberation(
5587: s_etat_processus,
5588: s_objet_evalue);
5589: }
5590:
1.2 bertrand 5591: (*s_etat_processus)
5592: .instruction_courante =
5593: instruction_courante;
5594: return(d_erreur);
5595: }
5596: }
1.57 ! bertrand 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: }
1.2 bertrand 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: {
1.56 bertrand 5660: if (presence_egalite ==
5661: d_vrai)
5662: {
5663: liberation(
5664: s_etat_processus,
5665: s_objet_evalue);
5666: }
5667:
1.2 bertrand 5668: (*s_etat_processus)
5669: .instruction_courante =
5670: instruction_courante;
5671: return(d_erreur);
5672: }
5673: }
1.57 ! bertrand 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: }
1.2 bertrand 5794: else
5795: {
1.56 bertrand 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: }
1.57 ! bertrand 5846:
! 5847: (*s_etat_processus)
! 5848: .sections_critiques--;
1.56 bertrand 5849: }
5850:
1.2 bertrand 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) ||
1.57 ! bertrand 5938: TEST(instruction_forall) ||
1.2 bertrand 5939: TEST(instruction_start) ||
5940: TEST(instruction_select) ||
5941: TEST(instruction_case) ||
1.56 bertrand 5942: TEST(instruction_critical) ||
1.2 bertrand 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: {
1.56 bertrand 5953: if (presence_egalite ==
5954: d_vrai)
5955: {
5956: liberation(
5957: s_etat_processus,
5958: s_objet_evalue);
5959: }
5960:
1.2 bertrand 5961: (*s_etat_processus)
5962: .instruction_courante =
5963: instruction_courante;
5964: return(d_erreur);
5965: }
5966: }
1.57 ! bertrand 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: }
1.2 bertrand 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: {
1.56 bertrand 6030: if (presence_egalite ==
6031: d_vrai)
6032: {
6033: liberation(
6034: s_etat_processus,
6035: s_objet_evalue);
6036: }
6037:
1.2 bertrand 6038: (*s_etat_processus)
6039: .instruction_courante =
6040: instruction_courante;
6041: return(d_erreur);
6042: }
6043: }
1.57 ! bertrand 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: }
1.2 bertrand 6164: else
6165: {
1.56 bertrand 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: }
1.57 ! bertrand 6216:
! 6217: (*s_etat_processus)
! 6218: .sections_critiques--;
1.56 bertrand 6219: }
6220:
1.2 bertrand 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: {
1.47 bertrand 6262: envoi_signal_processus((*s_etat_processus)
6263: .pid_processus_pere, rpl_sigalrm);
1.2 bertrand 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: }
1.1 bertrand 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: {
1.11 bertrand 6303: (*s_etat_processus).erreur_systeme = d_es;
6304: presence_variable = d_faux;
6305:
1.9 bertrand 6306: if ((*s_etat_processus).autorisation_nom_implicite
6307: == 'N')
6308: {
6309: if ((*((struct_nom *) (*s_objet_elementaire).objet))
6310: .symbole == d_faux)
6311: {
1.12 bertrand 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;
1.11 bertrand 6322: (*s_etat_processus).erreur_execution =
6323: d_ex_nom_implicite;
6324:
1.12 bertrand 6325: if (type_evaluation == 'I')
6326: {
6327: (*s_etat_processus)
6328: .derniere_erreur_evaluation =
6329: (*s_etat_processus)
6330: .erreur_execution;
6331: }
1.11 bertrand 6332: }
6333: }
1.1 bertrand 6334: }
6335: else
6336: {
6337: if ((*s_etat_processus).traitement_symbolique == 'N')
6338: {
1.34 bertrand 6339: if ((*(*s_etat_processus)
6340: .pointeur_variable_courante).objet == NULL)
1.1 bertrand 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(
1.34 bertrand 6356: s_etat_processus, (*(*s_etat_processus)
6357: .pointeur_variable_courante).nom,
6358: (*(*s_etat_processus)
6359: .pointeur_variable_courante)
1.1 bertrand 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:
1.34 bertrand 6437: if ((*(*(*s_etat_processus)
6438: .pointeur_variable_courante).objet)
6439: .type == ADR)
1.1 bertrand 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: {
1.19 bertrand 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.
1.1 bertrand 6461:
1.19 bertrand 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;
1.1 bertrand 6467:
1.19 bertrand 6468: (*s_etat_processus).erreur_systeme =
6469: d_es_allocation_memoire;
6470: return(d_erreur);
1.1 bertrand 6471: }
6472:
1.19 bertrand 6473: if (empilement(s_etat_processus,
6474: &((*s_etat_processus).l_base_pile),
6475: s_sous_objet) == d_erreur)
1.1 bertrand 6476: {
1.19 bertrand 6477: (*s_etat_processus).instruction_courante =
6478: instruction_courante;
6479: liberation(s_etat_processus, s_sous_objet);
6480: return(d_erreur);
1.1 bertrand 6481: }
1.19 bertrand 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);
1.1 bertrand 6492:
1.19 bertrand 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: }
1.1 bertrand 6500:
1.19 bertrand 6501: if (presence_egalite == d_vrai)
6502: {
6503: liberation(s_etat_processus,
6504: s_objet_evalue);
6505: }
1.1 bertrand 6506:
1.19 bertrand 6507: (*s_etat_processus).instruction_courante =
6508: instruction_courante;
6509: return(d_erreur);
6510: }
1.1 bertrand 6511:
1.19 bertrand 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';
1.1 bertrand 6516:
1.19 bertrand 6517: (*s_etat_processus).mode_execution_programme = 'Y';
6518: (*s_etat_processus)
6519: .autorisation_empilement_programme = 'N';
1.1 bertrand 6520:
1.19 bertrand 6521: (*(*s_etat_processus).l_base_pile_systeme)
6522: .niveau_courant = (*s_etat_processus)
6523: .niveau_courant;
1.1 bertrand 6524:
1.19 bertrand 6525: if (presence_variable_partagee == d_faux)
6526: {
6527: (*s_etat_processus).position_courante =
6528: (*((unsigned long *)
1.34 bertrand 6529: ((*(*(*s_etat_processus)
6530: .pointeur_variable_courante)
6531: .objet).objet)));
1.19 bertrand 6532: }
6533: else
1.1 bertrand 6534: {
1.19 bertrand 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);
1.1 bertrand 6540: }
6541:
1.19 bertrand 6542: if ((*s_etat_processus).profilage == d_vrai)
6543: {
6544: profilage(s_etat_processus,
1.34 bertrand 6545: (*(*s_etat_processus)
6546: .pointeur_variable_courante).nom);
1.19 bertrand 6547:
6548: if ((*s_etat_processus).erreur_systeme != d_es)
6549: {
6550: return(d_erreur);
6551: }
6552: }
1.4 bertrand 6553:
1.19 bertrand 6554: registre_evaluation_forcee =
6555: (*s_etat_processus).evaluation_forcee;
1.4 bertrand 6556:
1.19 bertrand 6557: if (type_evaluation == 'N')
6558: {
6559: (*s_etat_processus).evaluation_forcee = 'Y';
6560: }
1.4 bertrand 6561:
1.19 bertrand 6562: if (sequenceur(s_etat_processus) == d_erreur)
1.1 bertrand 6563: {
1.19 bertrand 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);
1.1 bertrand 6578: }
6579:
1.19 bertrand 6580: (*s_etat_processus).evaluation_forcee =
6581: registre_evaluation_forcee;
1.1 bertrand 6582: (*s_etat_processus).instruction_courante =
6583: instruction_courante;
1.19 bertrand 6584: (*s_etat_processus).mode_execution_programme = 'N';
1.1 bertrand 6585:
1.19 bertrand 6586: depilement_pile_systeme(s_etat_processus);
1.1 bertrand 6587:
1.19 bertrand 6588: if ((*s_etat_processus).erreur_systeme != d_es)
1.1 bertrand 6589: {
1.19 bertrand 6590: if (presence_egalite == d_vrai)
6591: {
6592: liberation(s_etat_processus,
6593: s_objet_evalue);
6594: }
6595:
6596: return(d_erreur);
1.1 bertrand 6597: }
6598:
1.19 bertrand 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;
1.1 bertrand 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,
1.34 bertrand 6617: (*(*s_etat_processus)
6618: .pointeur_variable_courante).objet,
1.1 bertrand 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:
1.34 bertrand 6687: if (((*(*s_etat_processus)
6688: .pointeur_variable_courante)
6689: .origine == 'E') && ((*(*s_etat_processus)
6690: .pointeur_variable_courante).niveau == 0))
1.1 bertrand 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,
1.34 bertrand 6706: (*(*s_etat_processus)
6707: .pointeur_variable_courante).nom);
1.1 bertrand 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,
1.34 bertrand 6730: (*(*s_etat_processus)
6731: .pointeur_variable_courante).objet,
1.1 bertrand 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 =
1.13 bertrand 6738: registre_niveau_courant;
1.1 bertrand 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 =
1.13 bertrand 6769: registre_niveau_courant;
1.1 bertrand 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,
1.34 bertrand 6779: (*(*s_etat_processus)
6780: .pointeur_variable_courante).nom);
1.1 bertrand 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: {
1.34 bertrand 6884: if ((*(*s_etat_processus)
6885: .pointeur_variable_courante).objet
1.1 bertrand 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,
1.34 bertrand 6902: (*(*s_etat_processus)
6903: .pointeur_variable_courante).nom,
6904: (*(*s_etat_processus)
6905: .pointeur_variable_courante)
1.1 bertrand 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,
1.34 bertrand 6965: (*(*s_etat_processus)
6966: .pointeur_variable_courante).objet,
1.1 bertrand 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: {
1.11 bertrand 7042: // Il est anormal de récupérer ici une erreur
7043: // d'exécution puisqu'on empile une constante
7044: // symbolique.
7045:
1.1 bertrand 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: }
1.57 ! bertrand 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:
1.1 bertrand 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:
1.34 bertrand 7146: if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
1.1 bertrand 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:
1.27 bertrand 7296: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
7297: ? 'E' : 'N';
7298: cf(s_etat_processus, 35);
7299:
1.1 bertrand 7300: analyse(s_etat_processus, (*((struct_fonction *)
7301: (*s_objet).objet)).fonction);
1.27 bertrand 7302: (*s_etat_processus).instruction_courante = instruction_courante;
1.1 bertrand 7303:
1.27 bertrand 7304: if (registre_type_evaluation == 'E')
7305: {
7306: sf(s_etat_processus, 35);
7307: }
7308: else
7309: {
7310: cf(s_etat_processus, 35);
7311: }
1.1 bertrand 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: {
1.29 bertrand 7324: (*s_etat_processus).instruction_courante = instruction_courante;
7325:
1.1 bertrand 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