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