1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.9
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25: #define TEST(instruction) (fonction == instruction)
26: #define vers_niveau_inferieur instruction_vers_niveau_inferieur
27: #define vers_niveau_superieur instruction_vers_niveau_superieur
28:
29:
30: /*
31: ================================================================================
32: Evaluation d'une expression
33: ================================================================================
34: Entrées :
35: structure processus,
36: objet à évaluer (non libéré au retour de la routine)
37: et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM')
38: --------------------------------------------------------------------------------
39: Sorties : objet évalué au niveau 1 de la pile
40: --------------------------------------------------------------------------------
41: Effets de bord : néant
42: ================================================================================
43: */
44:
45: logical1
46: evaluation(struct_processus *s_etat_processus, struct_objet *s_objet,
47: unsigned char type_evaluation)
48: {
49: integer8 i;
50: integer8 j;
51:
52: logical1 drapeau_then;
53: logical1 erreur_evaluation;
54: logical1 presence_egalite;
55: logical1 presence_fonction;
56: logical1 presence_variable;
57: logical1 presence_variable_partagee;
58:
59: struct_liste_chainee *l_element_courant;
60: struct_liste_chainee *l_element_egalite;
61: struct_liste_chainee *l_element_fonction;
62: struct_liste_chainee *l_liste1;
63: struct_liste_chainee *l_liste2;
64: struct_liste_chainee *l_registre_atome;
65: struct_liste_chainee *l_registre_pile_operationnelle;
66: struct_liste_chainee *l_sous_element_courant;
67: struct_liste_chainee *registre_expression_courante;
68:
69: struct_liste_pile_systeme *pile_systeme_originelle;
70:
71: struct_objet *s_objet_elementaire;
72: struct_objet *s_objet_evalue;
73: struct_objet *s_objet_indice_i;
74: struct_objet *s_objet_indice_j;
75: struct_objet *s_objet_tampon;
76: struct_objet *s_sous_objet;
77: struct_objet *s_copie_variable_partagee;
78:
79: struct_variable *registre_variables;
80:
81: unsigned char autorisation_empilement_programme;
82: unsigned char *instruction_courante;
83: unsigned char *message;
84: unsigned char registre_evaluation_expression_compilee;
85: unsigned char registre_instruction_valide;
86: unsigned char registre_mode_execution_programme;
87: unsigned char registre_retour_definition;
88: unsigned char registre_test;
89: unsigned char registre_test_2;
90: unsigned char registre_type_evaluation;
91:
92: unsigned int registre_erreur_execution;
93: unsigned int registre_erreur_systeme;
94: unsigned int registre_exception;
95:
96: unsigned long k;
97: unsigned long l;
98: unsigned long n;
99: unsigned long m;
100: unsigned long niveau_initial;
101: unsigned long nombre_termes;
102: unsigned long registre_hauteur_pile_operationnelle;
103: unsigned long registre_niveau_courant;
104: unsigned long registre_position_courante;
105:
106: void (*fonction)();
107:
108: registre_mode_execution_programme =
109: (*s_etat_processus).mode_execution_programme;
110: (*s_etat_processus).mode_execution_programme = 'I';
111: instruction_courante = (*s_etat_processus).instruction_courante;
112: (*s_etat_processus).erreur_execution = d_ex;
113:
114: erreur_evaluation = d_absence_erreur;
115: s_copie_variable_partagee = NULL;
116:
117: if ((*s_objet).type == NOM)
118: {
119: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
120: == NULL)
121: {
122: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
123: (*s_etat_processus).instruction_courante = instruction_courante;
124: return(d_erreur);
125: }
126:
127: registre_instruction_valide = (*s_etat_processus).instruction_valide;
128: registre_test = (*s_etat_processus).test_instruction;
129: (*s_etat_processus).test_instruction = 'Y';
130: (*s_etat_processus).instruction_courante = (*((struct_nom *)
131: (*s_objet_tampon).objet)).nom;
132:
133: analyse(s_etat_processus, NULL);
134:
135: (*s_etat_processus).test_instruction = 'N';
136:
137: if ((*s_etat_processus).constante_symbolique == 'N')
138: {
139: presence_fonction = d_faux;
140: presence_variable_partagee = d_faux;
141:
142: if (recherche_variable(s_etat_processus, (*((struct_nom *)
143: (*s_objet_tampon).objet)).nom) == d_faux)
144: {
145: (*s_etat_processus).erreur_systeme = d_es;
146: presence_variable = d_faux;
147: }
148: else
149: {
150: if ((*s_etat_processus).traitement_symbolique == 'N')
151: {
152: if ((*s_etat_processus).s_liste_variables
153: [(*s_etat_processus).position_variable_courante]
154: .objet == NULL)
155: {
156: // Variable partagée
157:
158: if (pthread_mutex_lock(&((*(*s_etat_processus)
159: .s_liste_variables_partagees).mutex)) != 0)
160: {
161: (*s_etat_processus).erreur_systeme =
162: d_es_processus;
163: return(d_erreur);
164: }
165:
166: presence_variable_partagee = d_faux;
167:
168: if (recherche_variable_partagee(s_etat_processus,
169: ((*s_etat_processus).s_liste_variables
170: [(*s_etat_processus)
171: .position_variable_courante]).nom,
172: ((*s_etat_processus).s_liste_variables
173: [(*s_etat_processus)
174: .position_variable_courante])
175: .variable_partagee, 'E') == d_vrai)
176: {
177: presence_variable = d_vrai;
178: presence_variable_partagee = d_vrai;
179:
180: if ((*((*(*s_etat_processus)
181: .s_liste_variables_partagees).table
182: [(*(*s_etat_processus)
183: .s_liste_variables_partagees)
184: .position_variable].objet)).type
185: == ADR)
186: {
187: presence_fonction = d_vrai;
188: }
189:
190: if ((s_copie_variable_partagee =
191: copie_objet(s_etat_processus,
192: (*(*s_etat_processus)
193: .s_liste_variables_partagees)
194: .table[(*(*s_etat_processus)
195: .s_liste_variables_partagees)
196: .position_variable].objet, 'P')) == NULL)
197: {
198: (*s_etat_processus).erreur_systeme =
199: d_es_allocation_memoire;
200:
201: if (pthread_mutex_unlock(&((*(*s_etat_processus)
202: .s_liste_variables_partagees).mutex))
203: != 0)
204: {
205: (*s_etat_processus).erreur_systeme =
206: d_es_processus;
207: return(d_erreur);
208: }
209:
210: return(d_erreur);
211: }
212:
213: if (pthread_mutex_unlock(&((*(*s_etat_processus)
214: .s_liste_variables_partagees).mutex))
215: != 0)
216: {
217: (*s_etat_processus).erreur_systeme =
218: d_es_processus;
219: return(d_erreur);
220: }
221: }
222: else
223: {
224: (*s_etat_processus).erreur_systeme = d_es;
225: presence_variable = d_faux;
226: presence_variable_partagee = d_faux;
227:
228: if (pthread_mutex_unlock(&((*(*s_etat_processus)
229: .s_liste_variables_partagees).mutex)) != 0)
230: {
231: (*s_etat_processus).erreur_systeme =
232: d_es_processus;
233: return(d_erreur);
234: }
235: }
236: }
237: else
238: {
239: // Variable privée
240:
241: presence_variable = d_vrai;
242:
243: if ((*((*s_etat_processus).s_liste_variables
244: [(*s_etat_processus).position_variable_courante]
245: .objet)).type == ADR)
246: {
247: presence_fonction = d_vrai;
248: }
249: }
250: }
251: else
252: {
253: presence_variable = d_faux;
254: }
255: }
256:
257: liberation(s_etat_processus, s_objet_tampon);
258:
259: if (presence_fonction == d_vrai)
260: {
261: autorisation_empilement_programme = (*s_etat_processus)
262: .autorisation_empilement_programme;
263: registre_position_courante = (*s_etat_processus)
264: .position_courante;
265:
266: empilement_pile_systeme(s_etat_processus);
267:
268: if ((*s_etat_processus).erreur_systeme != d_es)
269: {
270: if (presence_variable_partagee == d_vrai)
271: {
272: liberation(s_etat_processus, s_copie_variable_partagee);
273: }
274:
275: (*s_etat_processus).instruction_courante =
276: instruction_courante;
277: return(d_erreur);
278: }
279:
280: (*(*s_etat_processus).l_base_pile_systeme)
281: .retour_definition = 'Y';
282: (*(*s_etat_processus).l_base_pile_systeme)
283: .origine_routine_evaluation = 'Y';
284:
285: (*s_etat_processus).mode_execution_programme = 'Y';
286: (*s_etat_processus).autorisation_empilement_programme = 'N';
287:
288: (*(*s_etat_processus).l_base_pile_systeme)
289: .niveau_courant = (*s_etat_processus)
290: .niveau_courant;
291:
292: if (presence_variable_partagee == d_faux)
293: {
294: (*s_etat_processus).position_courante =
295: (*((unsigned long *)
296: ((*((*s_etat_processus).s_liste_variables
297: [(*s_etat_processus)
298: .position_variable_courante]
299: .objet)).objet)));
300: }
301: else
302: {
303: (*s_etat_processus).position_courante =
304: (*((unsigned long *) (*s_copie_variable_partagee)
305: .objet));
306: liberation(s_etat_processus, s_copie_variable_partagee);
307:
308: if (pthread_mutex_unlock(&((*(*s_etat_processus)
309: .s_liste_variables_partagees).mutex)) != 0)
310: {
311: (*s_etat_processus).erreur_systeme =
312: d_es_processus;
313: return(d_erreur);
314: }
315: }
316:
317: if ((*s_etat_processus).profilage == d_vrai)
318: {
319: profilage(s_etat_processus,
320: (*s_etat_processus).s_liste_variables
321: [(*s_etat_processus).position_variable_courante]
322: .nom);
323:
324: if ((*s_etat_processus).erreur_systeme != d_es)
325: {
326: return(d_erreur);
327: }
328: }
329:
330: if (sequenceur(s_etat_processus) == d_erreur)
331: {
332: (*s_etat_processus).mode_execution_programme =
333: registre_mode_execution_programme;
334: (*s_etat_processus).instruction_courante =
335: instruction_courante;
336: return(d_erreur);
337: }
338:
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:
361: if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)
362: .position_variable_courante].origine == 'E') &&
363: ((*s_etat_processus).s_liste_variables
364: [(*s_etat_processus).position_variable_courante].niveau
365: == 0))
366: {
367: (*s_etat_processus).evaluation_expression_compilee = 'Y';
368: }
369: else
370: {
371: (*s_etat_processus).evaluation_expression_compilee = 'N';
372: }
373:
374: if ((*s_etat_processus).profilage == d_vrai)
375: {
376: profilage(s_etat_processus,
377: (*s_etat_processus).s_liste_variables
378: [(*s_etat_processus).position_variable_courante]
379: .nom);
380:
381: if ((*s_etat_processus).erreur_systeme != d_es)
382: {
383: if (presence_variable_partagee == d_vrai)
384: {
385: if (pthread_mutex_unlock(&((*(*s_etat_processus)
386: .s_liste_variables_partagees).mutex)) != 0)
387: {
388: (*s_etat_processus).erreur_systeme =
389: d_es_processus;
390: return(d_erreur);
391: }
392: }
393:
394: return(d_erreur);
395: }
396: }
397:
398: if (presence_variable_partagee == d_faux)
399: {
400: if (evaluation(s_etat_processus, (*s_etat_processus)
401: .s_liste_variables[(*s_etat_processus)
402: .position_variable_courante].objet,
403: type_evaluation) == d_erreur)
404: {
405: if ((*s_etat_processus).profilage == d_vrai)
406: {
407: profilage(s_etat_processus, NULL);
408: }
409:
410: (*s_etat_processus).evaluation_expression_compilee =
411: registre_evaluation_expression_compilee;
412:
413: (*s_etat_processus).mode_execution_programme =
414: registre_mode_execution_programme;
415: (*s_etat_processus).instruction_courante =
416: instruction_courante;
417: return(d_erreur);
418: }
419: }
420: else
421: {
422: if (evaluation(s_etat_processus, s_copie_variable_partagee,
423: type_evaluation) == d_erreur)
424: {
425: liberation(s_etat_processus, s_copie_variable_partagee);
426:
427: if ((*s_etat_processus).profilage == d_vrai)
428: {
429: profilage(s_etat_processus, NULL);
430: }
431:
432: (*s_etat_processus).evaluation_expression_compilee =
433: registre_evaluation_expression_compilee;
434:
435: (*s_etat_processus).mode_execution_programme =
436: registre_mode_execution_programme;
437: (*s_etat_processus).instruction_courante =
438: instruction_courante;
439: return(d_erreur);
440: }
441:
442: liberation(s_etat_processus, s_copie_variable_partagee);
443: }
444:
445: if ((*s_etat_processus).profilage == d_vrai)
446: {
447: profilage(s_etat_processus, NULL);
448: }
449:
450: (*s_etat_processus).evaluation_expression_compilee =
451: registre_evaluation_expression_compilee;
452: }
453: else
454: {
455: if ((s_objet_tampon = copie_objet(s_etat_processus,
456: s_objet, 'P')) == NULL)
457: {
458: (*s_etat_processus).erreur_systeme =
459: d_es_allocation_memoire;
460: (*s_etat_processus).instruction_courante =
461: instruction_courante;
462: return(d_erreur);
463: }
464:
465: (*((struct_nom *) (*s_objet_tampon).objet)).symbole = d_vrai;
466:
467: if (empilement(s_etat_processus, &((*s_etat_processus)
468: .l_base_pile), s_objet_tampon) == d_erreur)
469: {
470: (*s_etat_processus).instruction_courante =
471: instruction_courante;
472: return(d_erreur);
473: }
474:
475: if ((*s_etat_processus).erreur_execution ==
476: d_ex_variable_non_definie)
477: {
478: (*s_etat_processus).erreur_execution = d_ex;
479: }
480: }
481: }
482: else
483: {
484: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
485: == d_vrai) ? 'E' : 'N';
486:
487: if (type_evaluation == 'N')
488: {
489: cf(s_etat_processus, 35);
490: }
491: else
492: {
493: sf(s_etat_processus, 35);
494: }
495:
496: analyse(s_etat_processus, NULL);
497: liberation(s_etat_processus, s_objet_tampon);
498:
499: if (registre_type_evaluation == 'E')
500: {
501: sf(s_etat_processus, 35);
502: }
503: else
504: {
505: cf(s_etat_processus, 35);
506: }
507:
508: if (((*s_etat_processus).erreur_systeme != d_es) ||
509: ((*s_etat_processus).erreur_execution != d_ex) ||
510: ((*s_etat_processus).exception != d_ep))
511: {
512: (*s_etat_processus).mode_execution_programme =
513: registre_mode_execution_programme;
514: (*s_etat_processus).instruction_courante = instruction_courante;
515: return(d_erreur);
516: }
517: }
518:
519: (*s_etat_processus).instruction_courante = instruction_courante;
520: (*s_etat_processus).test_instruction = registre_test;
521: (*s_etat_processus).instruction_valide = registre_instruction_valide;
522: }
523: else if (((*s_objet).type == RPN) || ((*s_objet).type == ALG))
524: {
525: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
526: l_element_egalite = NULL;
527: presence_egalite = d_faux;
528: nombre_termes = 0;
529:
530: while(l_element_courant != NULL)
531: {
532: if ((*(*l_element_courant).donnee).type == FCT)
533: {
534: if (strcmp((*((struct_fonction *) (*(*l_element_courant)
535: .donnee).objet)).nom_fonction, "=") == 0)
536: {
537: presence_egalite = d_vrai;
538: l_element_egalite = l_element_courant;
539: }
540: }
541:
542: l_element_courant = (*l_element_courant).suivant;
543: nombre_termes++;
544: }
545:
546: if (nombre_termes <= 4)
547: {
548: presence_egalite = d_faux;
549: }
550:
551: if (presence_egalite == d_vrai)
552: {
553: // S'il y a un signe '=', on modifie l'expression à évaluer en ôtant
554: // le signe '=' et en le remplaçant d'une part par SWAP DROP
555: // et d'autre part par DROP. On évalue la première puis la
556: // seconde normalement avant de reconstituer le tout à la fin
557: // de la routine.
558:
559: l_registre_pile_operationnelle = NULL;
560: registre_hauteur_pile_operationnelle = (*s_etat_processus)
561: .hauteur_pile_operationnelle;
562: l_element_courant = (*s_etat_processus).l_base_pile;
563:
564: while(l_element_courant != NULL)
565: {
566: s_sous_objet = copie_objet(s_etat_processus,
567: (*l_element_courant).donnee, 'O');
568:
569: if (s_sous_objet == NULL)
570: {
571: (*s_etat_processus).instruction_courante =
572: instruction_courante;
573: (*s_etat_processus).erreur_systeme =
574: d_es_allocation_memoire;
575: return(d_erreur);
576: }
577:
578: if (empilement(s_etat_processus,
579: &l_registre_pile_operationnelle, s_sous_objet)
580: == d_erreur)
581: {
582: (*s_etat_processus).instruction_courante =
583: instruction_courante;
584: (*s_etat_processus).erreur_systeme =
585: d_es_allocation_memoire;
586: return(d_erreur);
587: }
588:
589: l_element_courant = (*l_element_courant).suivant;
590: }
591:
592: free((*((struct_fonction *) (*(*l_element_egalite).donnee)
593: .objet)).nom_fonction);
594:
595: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
596: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
597: {
598: (*s_etat_processus).instruction_courante = instruction_courante;
599: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
600: return(d_erreur);
601: }
602:
603: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
604: .fonction = instruction_drop;
605: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
606: .nom_fonction, "DROP");
607:
608: if (evaluation(s_etat_processus, s_objet, type_evaluation)
609: == d_erreur)
610: {
611: (*s_etat_processus).instruction_courante = instruction_courante;
612: return(d_erreur);
613: }
614:
615: // Récupération de l'objet au niveau 1 résultat de l'évaluation
616: // du premier membre de l'équation puis destruction de la pile.
617:
618: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
619: &s_objet_evalue) == d_erreur)
620: {
621: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
622: (*s_etat_processus).instruction_courante = instruction_courante;
623: return(d_erreur);
624: }
625:
626: instruction_clear(s_etat_processus);
627:
628: // Régénération de la pile initiale
629:
630: while(depilement(s_etat_processus, &l_registre_pile_operationnelle,
631: &s_sous_objet) != d_erreur)
632: {
633: if (empilement(s_etat_processus, &((*s_etat_processus)
634: .l_base_pile), s_sous_objet) == d_erreur)
635: {
636: (*s_etat_processus).instruction_courante =
637: instruction_courante;
638: return(d_erreur);
639: }
640: }
641:
642: (*s_etat_processus).hauteur_pile_operationnelle =
643: registre_hauteur_pile_operationnelle;
644: (*s_etat_processus).erreur_execution = d_ex;
645:
646: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
647: .fonction = instruction_swap;
648: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
649: .nom_fonction, "SWAP");
650: l_element_courant = (*l_element_egalite).suivant;
651:
652: if (((*l_element_egalite).suivant =
653: malloc(sizeof(struct_liste_chainee))) == NULL)
654: {
655: liberation(s_etat_processus, s_objet_evalue);
656:
657: (*s_etat_processus).instruction_courante = instruction_courante;
658: return(d_erreur);
659: }
660:
661: l_element_egalite = (*l_element_egalite).suivant;
662: (*l_element_egalite).suivant = l_element_courant;
663:
664: if (((*l_element_egalite).donnee = allocation(s_etat_processus,
665: FCT)) == NULL)
666: {
667: liberation(s_etat_processus, s_objet_evalue);
668:
669: (*s_etat_processus).instruction_courante = instruction_courante;
670: return(d_erreur);
671: }
672:
673: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
674: .nombre_arguments = 0;
675: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
676: .fonction = instruction_drop;
677:
678: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
679: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
680: {
681: liberation(s_etat_processus, s_objet_evalue);
682:
683: (*s_etat_processus).instruction_courante = instruction_courante;
684: return(d_erreur);
685: }
686:
687: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet))
688: .nom_fonction, "DROP");
689: }
690:
691: /*
692: * Exécution de la séquence d'instructions
693: */
694:
695: registre_retour_definition = (*(*s_etat_processus).l_base_pile_systeme)
696: .retour_definition;
697: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
698:
699: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
700: autorisation_empilement_programme = (*s_etat_processus)
701: .autorisation_empilement_programme;
702: (*s_etat_processus).autorisation_empilement_programme = 'N';
703:
704: niveau_initial = (*s_etat_processus).niveau_courant;
705: pile_systeme_originelle = (*s_etat_processus).l_base_pile_systeme;
706:
707: while((l_element_courant != NULL) &&
708: ((*s_etat_processus).var_volatile_requete_arret == 0)
709: && (erreur_evaluation == d_absence_erreur) &&
710: (*s_etat_processus).requete_arret == 'N')
711: {
712: (*s_etat_processus).objet_courant = (*l_element_courant).donnee;
713:
714: if ((*(*l_element_courant).donnee).type == FCT)
715: {
716: /*
717: * Tester la cohérence avec une variable pour récupérer les
718: * données selon les indices passés en argument (tableaux,
719: * listes...).
720: */
721:
722: if (recherche_variable(s_etat_processus,
723: (*((struct_fonction *)
724: (*(*l_element_courant).donnee).objet)).nom_fonction)
725: == d_faux)
726: {
727: (*s_etat_processus).erreur_systeme = d_es;
728: (*s_etat_processus).instruction_courante =
729: (*((struct_fonction *) (*(*l_element_courant)
730: .donnee).objet)).nom_fonction;
731:
732: registre_expression_courante =
733: (*s_etat_processus).expression_courante;
734: (*s_etat_processus).expression_courante = l_element_courant;
735:
736: if (((*s_etat_processus).erreur_execution == d_ex) &&
737: ((*s_etat_processus).erreur_systeme == d_es) &&
738: ((*s_etat_processus).exception == d_ep))
739: {
740: analyse(s_etat_processus, (*((struct_fonction *)
741: (*(*l_element_courant).donnee).objet))
742: .fonction);
743:
744: if (type_evaluation == 'I')
745: {
746: (*s_etat_processus).derniere_erreur_evaluation =
747: (*s_etat_processus).erreur_execution;
748: }
749: }
750:
751: if ((*s_etat_processus).erreur_systeme != d_es)
752: {
753: if (presence_egalite == d_vrai)
754: {
755: liberation(s_etat_processus, s_objet_evalue);
756: }
757:
758: if ((*s_etat_processus).var_volatile_processus_pere
759: == 0)
760: {
761: kill((*s_etat_processus)
762: .pid_processus_pere, SIGALRM);
763: }
764: else
765: {
766: (*s_etat_processus).var_volatile_alarme = -1;
767: }
768:
769: (*s_etat_processus).instruction_courante =
770: instruction_courante;
771: return(d_erreur);
772: }
773: else if (((*s_etat_processus).erreur_execution != d_ex) ||
774: ((*s_etat_processus).exception != d_ep))
775: {
776: if ((*s_etat_processus).arret_si_exception == d_faux)
777: {
778: /*
779: * Reprise sur erreur
780: */
781:
782: if ((message = messages(s_etat_processus)) == NULL)
783: {
784: if (presence_egalite == d_vrai)
785: {
786: liberation(s_etat_processus,
787: s_objet_evalue);
788: }
789:
790: (*s_etat_processus).instruction_courante =
791: instruction_courante;
792: return(d_erreur);
793: }
794:
795: free(message);
796:
797: while((*(*s_etat_processus).l_base_pile_systeme)
798: .clause != 'R')
799: {
800: l_registre_atome = l_element_courant;
801: l_element_courant =
802: (*l_element_courant).suivant;
803:
804: if (l_element_courant == NULL)
805: {
806: /*
807: * La fin de l'expression est atteinte,
808: * le sequenceur reprend la main.
809: */
810:
811: if (presence_egalite == d_vrai)
812: {
813: liberation(s_etat_processus,
814: s_objet_evalue);
815: }
816:
817: (*s_etat_processus)
818: .mode_execution_programme =
819: registre_mode_execution_programme;
820: return(d_absence_erreur);
821: }
822:
823: if ((*(*l_element_courant).donnee).type == FCT)
824: {
825: (*s_etat_processus).instruction_courante =
826: (*((struct_fonction *)
827: (*(*l_element_courant).donnee)
828: .objet)).nom_fonction;
829:
830: if (recherche_variable(s_etat_processus,
831: (*s_etat_processus)
832: .instruction_courante) == d_faux)
833: {
834: (*s_etat_processus).erreur_systeme
835: = d_es;
836: fonction = (*((struct_fonction *)
837: (*(*l_element_courant).donnee)
838: .objet)).fonction;
839:
840: /*
841: * Traitement de la pile système par les
842: * différentes instructions.
843: */
844:
845: if (TEST(instruction_if) ||
846: TEST(instruction_iferr) ||
847: TEST(instruction_do) ||
848: TEST(instruction_while) ||
849: TEST(instruction_for) ||
850: TEST(instruction_start) ||
851: TEST(instruction_select) ||
852: TEST(instruction_case) ||
853: TEST(vers_niveau_superieur))
854: {
855: if (TEST(vers_niveau_superieur))
856: {
857: registre_exception =
858: (*s_etat_processus)
859: .exception;
860: registre_erreur_execution =
861: (*s_etat_processus)
862: .erreur_execution;
863:
864: analyse(s_etat_processus,
865: vers_niveau_superieur);
866:
867: (*s_etat_processus).exception
868: = registre_exception;
869: (*s_etat_processus)
870: .erreur_execution =
871: registre_erreur_execution;
872: }
873: else
874: {
875: empilement_pile_systeme(
876: s_etat_processus);
877:
878: if ((*s_etat_processus)
879: .erreur_systeme != d_es)
880: {
881: if (presence_egalite ==
882: d_vrai)
883: {
884: liberation(
885: s_etat_processus,
886: s_objet_evalue);
887: }
888:
889: (*s_etat_processus)
890: .instruction_courante =
891: instruction_courante;
892: return(d_erreur);
893: }
894: }
895: }
896: else if (TEST(instruction_end) ||
897: TEST(instruction_next) ||
898: TEST(instruction_step) ||
899: TEST(vers_niveau_inferieur))
900: {
901: if (TEST(vers_niveau_inferieur))
902: {
903: registre_exception =
904: (*s_etat_processus)
905: .exception;
906: registre_erreur_execution =
907: (*s_etat_processus)
908: .erreur_execution;
909:
910: analyse(s_etat_processus,
911: vers_niveau_inferieur);
912:
913: (*s_etat_processus).exception
914: = registre_exception;
915: (*s_etat_processus)
916: .erreur_execution =
917: registre_erreur_execution;
918: }
919: else
920: {
921: depilement_pile_systeme(
922: s_etat_processus);
923:
924: if ((*s_etat_processus)
925: .erreur_systeme != d_es)
926: {
927: if (presence_egalite ==
928: d_vrai)
929: {
930: liberation(
931: s_etat_processus,
932: s_objet_evalue);
933: }
934:
935: (*s_etat_processus)
936: .instruction_courante =
937: instruction_courante;
938: return(d_erreur);
939: }
940: }
941: }
942: }
943: }
944: }
945:
946: (*s_etat_processus).instruction_courante =
947: instruction_courante;
948: drapeau_then = d_faux;
949:
950: do
951: {
952: l_registre_atome = l_element_courant;
953:
954: if (l_element_courant == NULL)
955: {
956: /*
957: * La fin de l'expression est atteinte,
958: * le sequenceur reprend la main.
959: */
960:
961: if (presence_egalite == d_vrai)
962: {
963: liberation(s_etat_processus,
964: s_objet_evalue);
965: }
966:
967: (*s_etat_processus)
968: .mode_execution_programme =
969: registre_mode_execution_programme;
970: (*s_etat_processus).instruction_courante =
971: instruction_courante;
972: return(d_absence_erreur);
973: }
974:
975: if ((*(*l_element_courant).donnee).type == FCT)
976: {
977: (*s_etat_processus)
978: .instruction_courante =
979: (*((struct_fonction *)
980: (*(*l_element_courant).donnee)
981: .objet)).nom_fonction;
982: fonction = (*((struct_fonction *)
983: (*(*l_element_courant).donnee)
984: .objet)).fonction;
985: (*s_etat_processus).instruction_courante =
986: instruction_courante;
987:
988: drapeau_then = TEST(instruction_then)
989: ? d_vrai : d_faux;
990: }
991:
992: l_element_courant = (*l_element_courant)
993: .suivant;
994: } while(drapeau_then == d_faux);
995:
996: (*s_etat_processus).expression_courante =
997: l_registre_atome;
998:
999: (*(*s_etat_processus).l_base_pile_systeme)
1000: .clause = 'X';
1001: instruction_then(s_etat_processus);
1002:
1003: (*s_etat_processus).exception = d_ep;
1004: (*s_etat_processus).erreur_execution = d_ex;
1005: }
1006: else if ((*s_etat_processus).mode_evaluation_expression
1007: == 'Y')
1008: {
1009: /*
1010: * Reprise sur erreur
1011: */
1012:
1013: while(l_element_courant != NULL)
1014: {
1015: if ((*(*l_element_courant).donnee).type == FCT)
1016: {
1017: (*s_etat_processus).instruction_courante =
1018: (*((struct_fonction *)
1019: (*(*l_element_courant).donnee)
1020: .objet)).nom_fonction;
1021: fonction = (*((struct_fonction *)
1022: (*(*l_element_courant).donnee)
1023: .objet)).fonction;
1024:
1025: if (recherche_variable(s_etat_processus,
1026: (*s_etat_processus)
1027: .instruction_courante) == d_faux)
1028: {
1029: (*s_etat_processus).erreur_systeme
1030: = d_es;
1031:
1032: /*
1033: * Traitement de la pile système par les
1034: * différentes instructions.
1035: */
1036:
1037: if (TEST(instruction_if) ||
1038: TEST(instruction_iferr) ||
1039: TEST(instruction_do) ||
1040: TEST(instruction_while) ||
1041: TEST(instruction_for) ||
1042: TEST(instruction_start) ||
1043: TEST(instruction_select) ||
1044: TEST(instruction_case) ||
1045: TEST(vers_niveau_superieur))
1046: {
1047: if (TEST(vers_niveau_superieur))
1048: {
1049: analyse(s_etat_processus,
1050: vers_niveau_superieur);
1051: }
1052: else
1053: {
1054: empilement_pile_systeme(
1055: s_etat_processus);
1056:
1057: if ((*s_etat_processus)
1058: .erreur_systeme != d_es)
1059: {
1060: if (presence_egalite ==
1061: d_vrai)
1062: {
1063: liberation(
1064: s_etat_processus,
1065: s_objet_evalue);
1066: }
1067:
1068: (*s_etat_processus)
1069: .instruction_courante =
1070: instruction_courante;
1071: return(d_erreur);
1072: }
1073: }
1074: }
1075: else if (TEST(instruction_end) ||
1076: TEST(instruction_next) ||
1077: TEST(instruction_step) ||
1078: TEST(vers_niveau_inferieur))
1079: {
1080: if (TEST(vers_niveau_inferieur))
1081: {
1082: analyse(s_etat_processus,
1083: vers_niveau_inferieur);
1084: }
1085: else
1086: {
1087: depilement_pile_systeme(
1088: s_etat_processus);
1089:
1090: if ((*s_etat_processus)
1091: .erreur_systeme != d_es)
1092: {
1093: if (presence_egalite ==
1094: d_vrai)
1095: {
1096: liberation(
1097: s_etat_processus,
1098: s_objet_evalue);
1099: }
1100:
1101: (*s_etat_processus)
1102: .instruction_courante =
1103: instruction_courante;
1104: return(d_erreur);
1105: }
1106: }
1107: }
1108: }
1109: }
1110:
1111: l_element_courant =
1112: (*l_element_courant).suivant;
1113: }
1114:
1115: (*s_etat_processus).mode_execution_programme =
1116: registre_mode_execution_programme;
1117: (*s_etat_processus).instruction_courante =
1118: instruction_courante;
1119:
1120: (*s_etat_processus).exception = d_ep;
1121: (*s_etat_processus).erreur_execution = d_ex;
1122:
1123: erreur_evaluation = d_erreur;
1124:
1125: (*s_etat_processus).expression_courante =
1126: registre_expression_courante;
1127: }
1128: else
1129: {
1130: // On ne détruit pas les variables pour les inclure
1131: // dans le fichier rpl-core.
1132:
1133: (*s_etat_processus).gel_liste_variables = d_vrai;
1134:
1135: registre_erreur_execution =
1136: (*s_etat_processus).erreur_execution;
1137: registre_exception =
1138: (*s_etat_processus).exception;
1139: registre_erreur_systeme =
1140: (*s_etat_processus).erreur_systeme;
1141:
1142: (*s_etat_processus).s_objet_errone = s_objet;
1143: (*s_etat_processus).s_objet_erreur =
1144: (*l_element_courant).donnee;
1145:
1146: l_element_courant = (*l_element_courant).suivant;
1147:
1148: while(l_element_courant != NULL)
1149: {
1150: if ((*(*l_element_courant).donnee).type == FCT)
1151: {
1152: (*s_etat_processus).instruction_courante =
1153: (*((struct_fonction *)
1154: (*(*l_element_courant).donnee)
1155: .objet)).nom_fonction;
1156: fonction = (*((struct_fonction *)
1157: (*(*l_element_courant).donnee)
1158: .objet)).fonction;
1159:
1160: if (recherche_variable(s_etat_processus,
1161: (*s_etat_processus)
1162: .instruction_courante) == d_faux)
1163: {
1164: (*s_etat_processus).erreur_systeme
1165: = d_es;
1166:
1167: /*
1168: * Traitement de la pile système par les
1169: * différentes instructions.
1170: */
1171:
1172: if (TEST(instruction_if) ||
1173: TEST(instruction_iferr) ||
1174: TEST(instruction_do) ||
1175: TEST(instruction_while) ||
1176: TEST(instruction_for) ||
1177: TEST(instruction_start) ||
1178: TEST(instruction_select) ||
1179: TEST(instruction_case) ||
1180: TEST(vers_niveau_superieur))
1181: {
1182: if (TEST(vers_niveau_superieur))
1183: {
1184: analyse(s_etat_processus,
1185: vers_niveau_superieur);
1186: }
1187: else
1188: {
1189: empilement_pile_systeme(
1190: s_etat_processus);
1191:
1192: if ((*s_etat_processus)
1193: .erreur_systeme != d_es)
1194: {
1195: if (presence_egalite ==
1196: d_vrai)
1197: {
1198: liberation(
1199: s_etat_processus,
1200: s_objet_evalue);
1201: }
1202:
1203: (*s_etat_processus)
1204: .instruction_courante =
1205: instruction_courante;
1206: return(d_erreur);
1207: }
1208: }
1209: }
1210: else if (TEST(instruction_end) ||
1211: TEST(instruction_next) ||
1212: TEST(instruction_step) ||
1213: TEST(vers_niveau_inferieur))
1214: {
1215: if (TEST(vers_niveau_inferieur))
1216: {
1217: analyse(s_etat_processus,
1218: vers_niveau_inferieur);
1219: }
1220: else
1221: {
1222: depilement_pile_systeme(
1223: s_etat_processus);
1224:
1225: if ((*s_etat_processus)
1226: .erreur_systeme != d_es)
1227: {
1228: if (presence_egalite ==
1229: d_vrai)
1230: {
1231: liberation(
1232: s_etat_processus,
1233: s_objet_evalue);
1234: }
1235:
1236: (*s_etat_processus)
1237: .instruction_courante =
1238: instruction_courante;
1239: return(d_erreur);
1240: }
1241: }
1242: }
1243: }
1244: }
1245:
1246: l_element_courant =
1247: (*l_element_courant).suivant;
1248: }
1249:
1250: (*s_etat_processus).mode_execution_programme =
1251: registre_mode_execution_programme;
1252: (*s_etat_processus).instruction_courante =
1253: instruction_courante;
1254:
1255: if (presence_egalite == d_vrai)
1256: {
1257: liberation(s_etat_processus, s_objet_evalue);
1258: }
1259:
1260: if ((*s_etat_processus)
1261: .var_volatile_processus_pere == 0)
1262: {
1263: kill((*s_etat_processus)
1264: .pid_processus_pere, SIGALRM);
1265: }
1266: else
1267: {
1268: (*s_etat_processus).var_volatile_alarme = -1;
1269: }
1270:
1271: (*s_etat_processus).erreur_execution =
1272: registre_erreur_execution;
1273: (*s_etat_processus).erreur_systeme =
1274: registre_erreur_systeme;
1275: (*s_etat_processus).exception =
1276: registre_exception;
1277: return(d_erreur);
1278: }
1279: }
1280:
1281: if ((*s_etat_processus).instruction_valide == 'Y')
1282: {
1283: l_element_courant = (*s_etat_processus)
1284: .expression_courante;
1285: }
1286: else
1287: {
1288: /*
1289: * Régénération de la fonction en notation algébrique
1290: */
1291:
1292: if ((s_objet_elementaire = (struct_objet *)
1293: allocation(s_etat_processus, ALG)) == NULL)
1294: {
1295: if (presence_egalite == d_vrai)
1296: {
1297: liberation(s_etat_processus, s_objet_evalue);
1298: }
1299:
1300: (*s_etat_processus).erreur_systeme =
1301: d_es_allocation_memoire;
1302: (*s_etat_processus).instruction_courante =
1303: instruction_courante;
1304: return(d_erreur);
1305: }
1306:
1307: /*
1308: * Ouverture de l'expression
1309: */
1310:
1311: if (((*s_objet_elementaire).objet =
1312: (struct_liste_chainee *)
1313: malloc(sizeof(struct_liste_chainee))) == NULL)
1314: {
1315: if (presence_egalite == d_vrai)
1316: {
1317: liberation(s_etat_processus, s_objet_evalue);
1318: }
1319:
1320: (*s_etat_processus).erreur_systeme =
1321: d_es_allocation_memoire;
1322: (*s_etat_processus).instruction_courante =
1323: instruction_courante;
1324: return(d_erreur);
1325: }
1326:
1327: l_element_fonction = (*s_objet_elementaire).objet;
1328:
1329: if (((*l_element_fonction).donnee = (struct_objet *)
1330: allocation(s_etat_processus, FCT)) == NULL)
1331: {
1332: if (presence_egalite == d_vrai)
1333: {
1334: liberation(s_etat_processus, s_objet_evalue);
1335: }
1336:
1337: (*s_etat_processus).erreur_systeme =
1338: d_es_allocation_memoire;
1339: (*s_etat_processus).instruction_courante =
1340: instruction_courante;
1341: return(d_erreur);
1342: }
1343:
1344: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1345: .objet)).nombre_arguments = 0;
1346: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1347: .objet)).fonction =
1348: instruction_vers_niveau_superieur;
1349:
1350: if (((*((struct_fonction *) (*(*l_element_fonction)
1351: .donnee).objet)).nom_fonction =
1352: (unsigned char *) malloc(3 * sizeof(
1353: unsigned char))) == NULL)
1354: {
1355: if (presence_egalite == d_vrai)
1356: {
1357: liberation(s_etat_processus, s_objet_evalue);
1358: }
1359:
1360: (*s_etat_processus).erreur_systeme =
1361: d_es_allocation_memoire;
1362: (*s_etat_processus).instruction_courante =
1363: instruction_courante;
1364: return(d_erreur);
1365: }
1366:
1367: strcpy((*((struct_fonction *) (*(*l_element_fonction)
1368: .donnee).objet)).nom_fonction, "<<");
1369:
1370: /*
1371: * Ajout des arguments
1372: */
1373:
1374: for(k = (*((struct_fonction *)
1375: (*(*l_element_courant).donnee).objet))
1376: .nombre_arguments; k >= 1; k--)
1377: {
1378: if (((*l_element_fonction).suivant =
1379: (struct_liste_chainee *) malloc(sizeof(
1380: struct_liste_chainee))) == NULL)
1381: {
1382: if (presence_egalite == d_vrai)
1383: {
1384: liberation(s_etat_processus,
1385: s_objet_evalue);
1386: }
1387:
1388: (*s_etat_processus).erreur_systeme =
1389: d_es_allocation_memoire;
1390: (*s_etat_processus).instruction_courante =
1391: instruction_courante;
1392: return(d_erreur);
1393: }
1394:
1395: l_element_fonction = (*l_element_fonction).suivant;
1396:
1397: if (k > 1)
1398: {
1399: l_liste1 = (*s_etat_processus).l_base_pile;
1400:
1401: for(l = 2; l < k; l++)
1402: {
1403: l_liste1 = (*l_liste1).suivant;
1404: }
1405:
1406: l_liste2 = (*l_liste1).suivant;
1407: (*l_liste1).suivant = (*l_liste2).suivant;
1408: (*l_liste2).suivant = (*s_etat_processus)
1409: .l_base_pile;
1410: (*s_etat_processus).l_base_pile = l_liste2;
1411: }
1412:
1413: if (depilement(s_etat_processus,
1414: &((*s_etat_processus).l_base_pile),
1415: &s_sous_objet) == d_erreur)
1416: {
1417: if (presence_egalite == d_vrai)
1418: {
1419: liberation(s_etat_processus,
1420: s_objet_evalue);
1421: }
1422:
1423: (*s_etat_processus).erreur_execution =
1424: d_ex_manque_argument;
1425: (*s_etat_processus).instruction_courante =
1426: instruction_courante;
1427: (*s_etat_processus).mode_execution_programme =
1428: registre_mode_execution_programme;
1429: return(d_erreur);
1430: }
1431:
1432: (*l_element_fonction).donnee = s_sous_objet;
1433: }
1434:
1435: /*
1436: * Ajout de la fonction
1437: */
1438:
1439: if (((*l_element_fonction).suivant =
1440: (struct_liste_chainee *) malloc(sizeof(
1441: struct_liste_chainee))) == NULL)
1442: {
1443: if (presence_egalite == d_vrai)
1444: {
1445: liberation(s_etat_processus, s_objet_evalue);
1446: }
1447:
1448: (*s_etat_processus).erreur_systeme =
1449: d_es_allocation_memoire;
1450: (*s_etat_processus).instruction_courante =
1451: instruction_courante;
1452: return(d_erreur);
1453: }
1454:
1455: l_element_fonction = (*l_element_fonction).suivant;
1456:
1457: if (((*l_element_fonction).donnee =
1458: copie_objet(s_etat_processus,
1459: (*l_element_courant).donnee, 'P'))
1460: == NULL)
1461: {
1462: if (presence_egalite == d_vrai)
1463: {
1464: liberation(s_etat_processus, s_objet_evalue);
1465: }
1466:
1467: (*s_etat_processus).erreur_systeme =
1468: d_es_allocation_memoire;
1469: (*s_etat_processus).instruction_courante =
1470: instruction_courante;
1471: return(d_erreur);
1472: }
1473:
1474: /*
1475: * Clôture de l'expression
1476: */
1477:
1478: if (((*l_element_fonction).suivant =
1479: (struct_liste_chainee *) malloc(sizeof(
1480: struct_liste_chainee))) == NULL)
1481: {
1482: if (presence_egalite == d_vrai)
1483: {
1484: liberation(s_etat_processus, s_objet_evalue);
1485: }
1486:
1487: (*s_etat_processus).erreur_systeme =
1488: d_es_allocation_memoire;
1489: (*s_etat_processus).instruction_courante =
1490: instruction_courante;
1491: return(d_erreur);
1492: }
1493:
1494: l_element_fonction = (*l_element_fonction).suivant;
1495:
1496: if (((*l_element_fonction).donnee =
1497: allocation(s_etat_processus, FCT)) == NULL)
1498: {
1499: if (presence_egalite == d_vrai)
1500: {
1501: liberation(s_etat_processus, s_objet_evalue);
1502: }
1503:
1504: (*s_etat_processus).erreur_systeme =
1505: d_es_allocation_memoire;
1506: (*s_etat_processus).instruction_courante =
1507: instruction_courante;
1508: return(d_erreur);
1509: }
1510:
1511: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1512: .objet)).nombre_arguments = 0;
1513: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1514: .objet)).fonction =
1515: instruction_vers_niveau_inferieur;
1516:
1517: if (((*((struct_fonction *) (*(*l_element_fonction)
1518: .donnee).objet)).nom_fonction =
1519: (unsigned char *) malloc(3 * sizeof(
1520: unsigned char))) == NULL)
1521: {
1522: if (presence_egalite == d_vrai)
1523: {
1524: liberation(s_etat_processus, s_objet_evalue);
1525: }
1526:
1527: (*s_etat_processus).erreur_systeme =
1528: d_es_allocation_memoire;
1529: (*s_etat_processus).instruction_courante =
1530: instruction_courante;
1531: return(d_erreur);
1532: }
1533:
1534: strcpy((*((struct_fonction *) (*(*l_element_fonction)
1535: .donnee).objet)).nom_fonction, ">>");
1536:
1537: (*l_element_fonction).suivant = NULL;
1538:
1539: if (empilement(s_etat_processus, &((*s_etat_processus)
1540: .l_base_pile), s_objet_elementaire) ==
1541: d_erreur)
1542: {
1543: if (presence_egalite == d_vrai)
1544: {
1545: liberation(s_etat_processus, s_objet_evalue);
1546: }
1547:
1548: (*s_etat_processus).instruction_courante =
1549: instruction_courante;
1550: return(d_erreur);
1551: }
1552: }
1553:
1554: (*s_etat_processus).expression_courante =
1555: registre_expression_courante;
1556: }
1557: else
1558: {
1559: if ((s_objet_elementaire =
1560: allocation(s_etat_processus, NON)) == NULL)
1561: {
1562: if (presence_egalite == d_vrai)
1563: {
1564: liberation(s_etat_processus, s_objet_evalue);
1565: }
1566:
1567: (*s_etat_processus).erreur_systeme =
1568: d_es_allocation_memoire;
1569: (*s_etat_processus).instruction_courante =
1570: instruction_courante;
1571: return(d_erreur);
1572: }
1573:
1574: if ((*s_etat_processus).s_liste_variables
1575: [(*s_etat_processus).position_variable_courante]
1576: .objet == NULL)
1577: {
1578: if (pthread_mutex_lock(&((*(*s_etat_processus)
1579: .s_liste_variables_partagees).mutex)) != 0)
1580: {
1581: (*s_etat_processus).erreur_systeme =
1582: d_es_processus;
1583: }
1584:
1585: if (recherche_variable_partagee(s_etat_processus,
1586: ((*s_etat_processus).s_liste_variables
1587: [(*s_etat_processus)
1588: .position_variable_courante]).nom,
1589: ((*s_etat_processus).s_liste_variables
1590: [(*s_etat_processus)
1591: .position_variable_courante])
1592: .variable_partagee, 'E') == d_vrai)
1593: {
1594: // Une variable partagée existe.
1595:
1596: presence_variable_partagee = d_vrai;
1597:
1598: (*s_etat_processus).s_liste_variables
1599: [(*s_etat_processus)
1600: .position_variable_courante].objet =
1601: (*(*s_etat_processus)
1602: .s_liste_variables_partagees).table
1603: [(*(*s_etat_processus)
1604: .s_liste_variables_partagees)
1605: .position_variable].objet;
1606: }
1607: else
1608: {
1609: presence_variable_partagee = d_faux;
1610:
1611: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1612: .s_liste_variables_partagees).mutex)) != 0)
1613: {
1614: (*s_etat_processus).erreur_systeme =
1615: d_es_processus;
1616: }
1617: }
1618: }
1619: else
1620: {
1621: presence_variable_partagee = d_faux;
1622: }
1623:
1624: /*
1625: * Recherche d'un élément dans un vecteur
1626: */
1627:
1628: if (((*s_etat_processus).s_liste_variables
1629: [(*s_etat_processus).position_variable_courante])
1630: .objet == NULL)
1631: {
1632: // La variable partagée n'existe plus.
1633:
1634: free(s_objet_elementaire);
1635:
1636: if ((s_objet_elementaire =
1637: copie_objet(s_etat_processus,
1638: (*l_element_courant).donnee, 'P')) == NULL)
1639: {
1640: if (presence_variable_partagee == d_vrai)
1641: {
1642: (*s_etat_processus).s_liste_variables
1643: [(*s_etat_processus)
1644: .position_variable_courante].objet =
1645: NULL;
1646:
1647: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1648: .s_liste_variables_partagees).mutex))
1649: != 0)
1650: {
1651: (*s_etat_processus).erreur_systeme =
1652: d_es_processus;
1653: }
1654: }
1655:
1656: (*s_etat_processus).erreur_systeme =
1657: d_es_allocation_memoire;
1658: return(d_erreur);;
1659: }
1660: }
1661: else if ((((*(((*s_etat_processus).s_liste_variables
1662: [(*s_etat_processus).position_variable_courante])
1663: .objet)).type == VIN) ||
1664: ((*(((*s_etat_processus).s_liste_variables
1665: [(*s_etat_processus).position_variable_courante])
1666: .objet)).type == VRL) ||
1667: ((*(((*s_etat_processus).s_liste_variables
1668: [(*s_etat_processus).position_variable_courante])
1669: .objet)).type == VCX))
1670: && ((*((struct_fonction *) (*(*l_element_courant)
1671: .donnee).objet)).nombre_arguments == 1))
1672: {
1673: if (depilement(s_etat_processus, &((*s_etat_processus)
1674: .l_base_pile), &s_objet_indice_i) == d_erreur)
1675: {
1676: free(s_objet_elementaire);
1677:
1678: if (presence_variable_partagee == d_vrai)
1679: {
1680: (*s_etat_processus).s_liste_variables
1681: [(*s_etat_processus)
1682: .position_variable_courante].objet =
1683: NULL;
1684:
1685: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1686: .s_liste_variables_partagees).mutex))
1687: != 0)
1688: {
1689: (*s_etat_processus).erreur_systeme =
1690: d_es_processus;
1691: }
1692: }
1693:
1694: if (presence_egalite == d_vrai)
1695: {
1696: liberation(s_etat_processus, s_objet_evalue);
1697: }
1698:
1699: (*s_etat_processus).erreur_execution =
1700: d_ex_manque_argument;
1701: (*s_etat_processus).instruction_courante =
1702: instruction_courante;
1703: (*s_etat_processus).mode_execution_programme =
1704: registre_mode_execution_programme;
1705: return(d_erreur);
1706: }
1707:
1708: if ((*s_objet_indice_i).type == INT)
1709: {
1710: liberation(s_etat_processus, s_objet_indice_i);
1711: free(s_objet_elementaire);
1712:
1713: if (presence_variable_partagee == d_vrai)
1714: {
1715: (*s_etat_processus).s_liste_variables
1716: [(*s_etat_processus)
1717: .position_variable_courante].objet =
1718: NULL;
1719:
1720: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1721: .s_liste_variables_partagees).mutex))
1722: != 0)
1723: {
1724: (*s_etat_processus).erreur_systeme =
1725: d_es_processus;
1726: }
1727: }
1728:
1729: if (presence_egalite == d_vrai)
1730: {
1731: liberation(s_etat_processus, s_objet_evalue);
1732: }
1733:
1734: (*s_etat_processus).erreur_execution =
1735: d_ex_erreur_type_argument;
1736: (*s_etat_processus).instruction_courante =
1737: instruction_courante;
1738: (*s_etat_processus).mode_execution_programme =
1739: registre_mode_execution_programme;
1740: return(d_erreur);
1741: }
1742:
1743: i = (*((integer8 *) (*s_objet_indice_i).objet));
1744:
1745: liberation(s_etat_processus, s_objet_indice_i);
1746:
1747: if ((i < 1) || (i > (integer8) (*((struct_vecteur *)
1748: (*(((*s_etat_processus)
1749: .s_liste_variables[(*s_etat_processus)
1750: .position_variable_courante]).objet)).objet))
1751: .taille))
1752: {
1753: free(s_objet_elementaire);
1754:
1755: if (presence_variable_partagee == d_vrai)
1756: {
1757: (*s_etat_processus).s_liste_variables
1758: [(*s_etat_processus)
1759: .position_variable_courante].objet =
1760: NULL;
1761:
1762: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1763: .s_liste_variables_partagees).mutex))
1764: != 0)
1765: {
1766: (*s_etat_processus).erreur_systeme =
1767: d_es_processus;
1768: }
1769: }
1770:
1771: if (presence_egalite == d_vrai)
1772: {
1773: liberation(s_etat_processus, s_objet_evalue);
1774: }
1775:
1776: (*s_etat_processus).erreur_execution =
1777: d_ex_element_inexistant;
1778: (*s_etat_processus).instruction_courante =
1779: instruction_courante;
1780: (*s_etat_processus).mode_execution_programme =
1781: registre_mode_execution_programme;
1782: return(d_erreur);
1783: }
1784:
1785: if ((*(((*s_etat_processus).s_liste_variables
1786: [(*s_etat_processus)
1787: .position_variable_courante]).objet)).type
1788: == VIN)
1789: {
1790: if (((*s_objet_elementaire).objet = malloc(sizeof(
1791: integer8))) == NULL)
1792: {
1793: if (presence_egalite == d_vrai)
1794: {
1795: liberation(s_etat_processus,
1796: s_objet_evalue);
1797: }
1798:
1799: if (presence_variable_partagee == d_vrai)
1800: {
1801: (*s_etat_processus).s_liste_variables
1802: [(*s_etat_processus)
1803: .position_variable_courante].objet
1804: = NULL;
1805:
1806: if (pthread_mutex_unlock(
1807: &((*(*s_etat_processus)
1808: .s_liste_variables_partagees)
1809: .mutex)) != 0)
1810: {
1811: (*s_etat_processus).erreur_systeme =
1812: d_es_processus;
1813: }
1814: }
1815:
1816: (*s_etat_processus).erreur_systeme =
1817: d_es_allocation_memoire;
1818: (*s_etat_processus).instruction_courante =
1819: instruction_courante;
1820: return(d_erreur);
1821: }
1822:
1823: (*s_objet_elementaire).type = INT;
1824: (*((integer8 *) (*s_objet_elementaire).objet)) =
1825: ((integer8 *) (*((struct_vecteur *)
1826: (*(((*s_etat_processus).s_liste_variables
1827: [(*s_etat_processus)
1828: .position_variable_courante]).objet))
1829: .objet)).tableau)[i - 1];
1830: }
1831: else if ((*(((*s_etat_processus)
1832: .s_liste_variables[(*s_etat_processus)
1833: .position_variable_courante]).objet)).type
1834: == VRL)
1835: {
1836: if (((*s_objet_elementaire).objet = malloc(sizeof(
1837: real8))) == NULL)
1838: {
1839: if (presence_variable_partagee == d_vrai)
1840: {
1841: (*s_etat_processus).s_liste_variables
1842: [(*s_etat_processus)
1843: .position_variable_courante].objet
1844: = NULL;
1845:
1846: if (pthread_mutex_unlock(
1847: &((*(*s_etat_processus)
1848: .s_liste_variables_partagees)
1849: .mutex)) != 0)
1850: {
1851: (*s_etat_processus).erreur_systeme =
1852: d_es_processus;
1853: }
1854: }
1855:
1856: if (presence_egalite == d_vrai)
1857: {
1858: liberation(s_etat_processus,
1859: s_objet_evalue);
1860: }
1861:
1862: (*s_etat_processus).erreur_systeme =
1863: d_es_allocation_memoire;
1864: (*s_etat_processus).instruction_courante =
1865: instruction_courante;
1866: return(d_erreur);
1867: }
1868:
1869: (*s_objet_elementaire).type = REL;
1870: (*((real8 *) (*s_objet_elementaire).objet)) =
1871: ((real8 *) (*((struct_vecteur *)
1872: (*(((*s_etat_processus).s_liste_variables
1873: [(*s_etat_processus)
1874: .position_variable_courante]).objet))
1875: .objet)).tableau)[i - 1];
1876: }
1877: else if ((*(((*s_etat_processus)
1878: .s_liste_variables[(*s_etat_processus)
1879: .position_variable_courante]).objet)).type
1880: == VCX)
1881: {
1882: if (((*s_objet_elementaire).objet = malloc(sizeof(
1883: struct_complexe16))) == NULL)
1884: {
1885: if (presence_variable_partagee == d_vrai)
1886: {
1887: (*s_etat_processus).s_liste_variables
1888: [(*s_etat_processus)
1889: .position_variable_courante].objet
1890: = NULL;
1891:
1892: if (pthread_mutex_unlock(
1893: &((*(*s_etat_processus)
1894: .s_liste_variables_partagees)
1895: .mutex)) != 0)
1896: {
1897: (*s_etat_processus).erreur_systeme =
1898: d_es_processus;
1899: }
1900: }
1901:
1902: if (presence_egalite == d_vrai)
1903: {
1904: liberation(s_etat_processus,
1905: s_objet_evalue);
1906: }
1907:
1908: (*s_etat_processus).erreur_systeme =
1909: d_es_allocation_memoire;
1910: (*s_etat_processus).instruction_courante =
1911: instruction_courante;
1912: return(d_erreur);
1913: }
1914:
1915: (*s_objet_elementaire).type = CPL;
1916: (*((struct_complexe16 *) (*s_objet_elementaire)
1917: .objet)).partie_reelle =
1918: ((struct_complexe16 *) (*((struct_vecteur *)
1919: (*(((*s_etat_processus).s_liste_variables
1920: [(*s_etat_processus)
1921: .position_variable_courante]).objet))
1922: .objet)).tableau)[i - 1]
1923: .partie_reelle;
1924: (*((struct_complexe16 *) (*s_objet_elementaire)
1925: .objet)).partie_imaginaire =
1926: ((struct_complexe16 *) (*((struct_vecteur *)
1927: (*(((*s_etat_processus).s_liste_variables
1928: [(*s_etat_processus)
1929: .position_variable_courante]).objet))
1930: .objet)).tableau)[i - 1]
1931: .partie_imaginaire;
1932: }
1933: }
1934:
1935: /*
1936: * Recherche d'un élément dans une matrice
1937: */
1938:
1939: else if ((((*(((*s_etat_processus).s_liste_variables
1940: [(*s_etat_processus).position_variable_courante])
1941: .objet)).type == MIN) ||
1942: ((*(((*s_etat_processus).s_liste_variables
1943: [(*s_etat_processus).position_variable_courante])
1944: .objet)).type == MRL) ||
1945: ((*(((*s_etat_processus).s_liste_variables
1946: [(*s_etat_processus).position_variable_courante])
1947: .objet)).type == MCX))
1948: && ((*((struct_fonction *) (*(*l_element_courant)
1949: .donnee).objet)).nombre_arguments == 2))
1950: {
1951: if (depilement(s_etat_processus, &((*s_etat_processus)
1952: .l_base_pile), &s_objet_indice_j) == d_erreur)
1953: {
1954: free(s_objet_elementaire);
1955:
1956: if (presence_variable_partagee == d_vrai)
1957: {
1958: (*s_etat_processus).s_liste_variables
1959: [(*s_etat_processus)
1960: .position_variable_courante].objet
1961: = NULL;
1962:
1963: if (pthread_mutex_unlock(
1964: &((*(*s_etat_processus)
1965: .s_liste_variables_partagees)
1966: .mutex)) != 0)
1967: {
1968: (*s_etat_processus).erreur_systeme =
1969: d_es_processus;
1970: }
1971: }
1972:
1973: if (presence_egalite == d_vrai)
1974: {
1975: liberation(s_etat_processus, s_objet_evalue);
1976: }
1977:
1978: (*s_etat_processus).erreur_execution =
1979: d_ex_manque_argument;
1980: (*s_etat_processus).instruction_courante =
1981: instruction_courante;
1982: (*s_etat_processus).mode_execution_programme =
1983: registre_mode_execution_programme;
1984: return(d_erreur);
1985: }
1986:
1987: if (depilement(s_etat_processus, &((*s_etat_processus)
1988: .l_base_pile), &s_objet_indice_i) == d_erreur)
1989: {
1990: liberation(s_etat_processus, s_objet_indice_j);
1991: free(s_objet_elementaire);
1992:
1993: if (presence_variable_partagee == d_vrai)
1994: {
1995: (*s_etat_processus).s_liste_variables
1996: [(*s_etat_processus)
1997: .position_variable_courante].objet
1998: = NULL;
1999:
2000: if (pthread_mutex_unlock(
2001: &((*(*s_etat_processus)
2002: .s_liste_variables_partagees)
2003: .mutex)) != 0)
2004: {
2005: (*s_etat_processus).erreur_systeme =
2006: d_es_processus;
2007: }
2008: }
2009:
2010: if (presence_egalite == d_vrai)
2011: {
2012: liberation(s_etat_processus, s_objet_evalue);
2013: }
2014:
2015: (*s_etat_processus).erreur_execution =
2016: d_ex_manque_argument;
2017: (*s_etat_processus).instruction_courante =
2018: instruction_courante;
2019: (*s_etat_processus).mode_execution_programme =
2020: registre_mode_execution_programme;
2021: return(d_erreur);
2022: }
2023:
2024: if (((*s_objet_indice_i).type != INT) ||
2025: ((*s_objet_indice_j).type != INT))
2026: {
2027: liberation(s_etat_processus, s_objet_indice_i);
2028: liberation(s_etat_processus, s_objet_indice_j);
2029: free(s_objet_elementaire);
2030:
2031: if (presence_variable_partagee == d_vrai)
2032: {
2033: (*s_etat_processus).s_liste_variables
2034: [(*s_etat_processus)
2035: .position_variable_courante].objet
2036: = NULL;
2037:
2038: if (pthread_mutex_unlock(
2039: &((*(*s_etat_processus)
2040: .s_liste_variables_partagees)
2041: .mutex)) != 0)
2042: {
2043: (*s_etat_processus).erreur_systeme =
2044: d_es_processus;
2045: }
2046: }
2047:
2048: if (presence_egalite == d_vrai)
2049: {
2050: liberation(s_etat_processus, s_objet_evalue);
2051: }
2052:
2053: (*s_etat_processus).erreur_execution =
2054: d_ex_erreur_type_argument;
2055: (*s_etat_processus).instruction_courante =
2056: instruction_courante;
2057: (*s_etat_processus).mode_execution_programme =
2058: registre_mode_execution_programme;
2059: return(d_erreur);
2060: }
2061:
2062: i = (*((integer8 *) (*s_objet_indice_i).objet));
2063: j = (*((integer8 *) (*s_objet_indice_j).objet));
2064:
2065: liberation(s_etat_processus, s_objet_indice_i);
2066: liberation(s_etat_processus, s_objet_indice_j);
2067:
2068: if ((i < 1) || (i > (integer8) (*((struct_matrice *)
2069: (*(((*s_etat_processus)
2070: .s_liste_variables[(*s_etat_processus)
2071: .position_variable_courante]).objet)).objet))
2072: .nombre_lignes) || (j < 1) || (j > (integer8)
2073: (*((struct_matrice *) (*(((*s_etat_processus)
2074: .s_liste_variables[(*s_etat_processus)
2075: .position_variable_courante]).objet)).objet))
2076: .nombre_colonnes))
2077: {
2078: liberation(s_etat_processus, s_objet_indice_i);
2079: liberation(s_etat_processus, s_objet_indice_j);
2080: free(s_objet_elementaire);
2081:
2082: if (presence_variable_partagee == d_vrai)
2083: {
2084: (*s_etat_processus).s_liste_variables
2085: [(*s_etat_processus)
2086: .position_variable_courante].objet
2087: = NULL;
2088:
2089: if (pthread_mutex_unlock(
2090: &((*(*s_etat_processus)
2091: .s_liste_variables_partagees)
2092: .mutex)) != 0)
2093: {
2094: (*s_etat_processus).erreur_systeme =
2095: d_es_processus;
2096: }
2097: }
2098:
2099: if (presence_egalite == d_vrai)
2100: {
2101: liberation(s_etat_processus, s_objet_evalue);
2102: }
2103:
2104: (*s_etat_processus).erreur_execution =
2105: d_ex_element_inexistant;
2106: (*s_etat_processus).instruction_courante =
2107: instruction_courante;
2108: (*s_etat_processus).mode_execution_programme =
2109: registre_mode_execution_programme;
2110: return(d_erreur);
2111: }
2112:
2113: if ((*(((*s_etat_processus).s_liste_variables
2114: [(*s_etat_processus)
2115: .position_variable_courante]).objet)).type
2116: == MIN)
2117: {
2118: if (((*s_objet_elementaire).objet = malloc(sizeof(
2119: integer8))) == NULL)
2120: {
2121: if (presence_variable_partagee == d_vrai)
2122: {
2123: (*s_etat_processus).s_liste_variables
2124: [(*s_etat_processus)
2125: .position_variable_courante].objet
2126: = NULL;
2127:
2128: if (pthread_mutex_unlock(
2129: &((*(*s_etat_processus)
2130: .s_liste_variables_partagees)
2131: .mutex)) != 0)
2132: {
2133: (*s_etat_processus).erreur_systeme =
2134: d_es_processus;
2135: }
2136: }
2137:
2138: if (presence_egalite == d_vrai)
2139: {
2140: liberation(s_etat_processus,
2141: s_objet_evalue);
2142: }
2143:
2144: (*s_etat_processus).erreur_systeme =
2145: d_es_allocation_memoire;
2146: (*s_etat_processus).instruction_courante =
2147: instruction_courante;
2148: return(d_erreur);
2149: }
2150:
2151: (*s_objet_elementaire).type = INT;
2152: (*((integer8 *) (*s_objet_elementaire).objet)) =
2153: ((integer8 **) (*((struct_matrice *)
2154: (*(((*s_etat_processus).s_liste_variables
2155: [(*s_etat_processus)
2156: .position_variable_courante]).objet))
2157: .objet)).tableau)[i - 1][j - 1];
2158: }
2159: else if ((*(((*s_etat_processus)
2160: .s_liste_variables[(*s_etat_processus)
2161: .position_variable_courante]).objet)).type
2162: == MRL)
2163: {
2164: if (((*s_objet_elementaire).objet = malloc(sizeof(
2165: real8))) == NULL)
2166: {
2167: if (presence_variable_partagee == d_vrai)
2168: {
2169: (*s_etat_processus).s_liste_variables
2170: [(*s_etat_processus)
2171: .position_variable_courante].objet
2172: = NULL;
2173:
2174: if (pthread_mutex_unlock(
2175: &((*(*s_etat_processus)
2176: .s_liste_variables_partagees)
2177: .mutex)) != 0)
2178: {
2179: (*s_etat_processus).erreur_systeme =
2180: d_es_processus;
2181: }
2182: }
2183:
2184: if (presence_egalite == d_vrai)
2185: {
2186: liberation(s_etat_processus,
2187: s_objet_evalue);
2188: }
2189:
2190: (*s_etat_processus).erreur_systeme =
2191: d_es_allocation_memoire;
2192: (*s_etat_processus).instruction_courante =
2193: instruction_courante;
2194: return(d_erreur);
2195: }
2196:
2197: (*s_objet_elementaire).type = REL;
2198: (*((real8 *) (*s_objet_elementaire).objet)) =
2199: ((real8 **) (*((struct_matrice *)
2200: (*(((*s_etat_processus).s_liste_variables
2201: [(*s_etat_processus)
2202: .position_variable_courante]).objet))
2203: .objet)).tableau)[i - 1][j - 1];
2204: }
2205: else if ((*(((*s_etat_processus)
2206: .s_liste_variables[(*s_etat_processus)
2207: .position_variable_courante]).objet)).type
2208: == MCX)
2209: {
2210: if (((*s_objet_elementaire).objet = malloc(sizeof(
2211: struct_complexe16))) == NULL)
2212: {
2213: if (presence_variable_partagee == d_vrai)
2214: {
2215: (*s_etat_processus).s_liste_variables
2216: [(*s_etat_processus)
2217: .position_variable_courante].objet
2218: = NULL;
2219:
2220: if (pthread_mutex_unlock(
2221: &((*(*s_etat_processus)
2222: .s_liste_variables_partagees)
2223: .mutex)) != 0)
2224: {
2225: (*s_etat_processus).erreur_systeme =
2226: d_es_processus;
2227: }
2228: }
2229:
2230: if (presence_egalite == d_vrai)
2231: {
2232: liberation(s_etat_processus,
2233: s_objet_evalue);
2234: }
2235:
2236: (*s_etat_processus).erreur_systeme =
2237: d_es_allocation_memoire;
2238: (*s_etat_processus).instruction_courante =
2239: instruction_courante;
2240: return(d_erreur);
2241: }
2242:
2243: (*s_objet_elementaire).type = CPL;
2244: (*((struct_complexe16 *) (*s_objet_elementaire)
2245: .objet)).partie_reelle =
2246: ((struct_complexe16 **)
2247: (*((struct_matrice *)
2248: (*(((*s_etat_processus).s_liste_variables
2249: [(*s_etat_processus)
2250: .position_variable_courante]).objet))
2251: .objet)).tableau)[i - 1][j - 1]
2252: .partie_reelle;
2253: (*((struct_complexe16 *) (*s_objet_elementaire)
2254: .objet)).partie_imaginaire =
2255: ((struct_complexe16 **)
2256: (*((struct_matrice *)
2257: (*(((*s_etat_processus).s_liste_variables
2258: [(*s_etat_processus)
2259: .position_variable_courante]).objet))
2260: .objet)).tableau)[i - 1][j - 1]
2261: .partie_imaginaire;
2262: }
2263: }
2264:
2265: /*
2266: * Recherche de l'élément idoine dans la liste
2267: */
2268:
2269: else if (((*(((*s_etat_processus).s_liste_variables
2270: [(*s_etat_processus).position_variable_courante])
2271: .objet)).type == LST) &&
2272: ((*((struct_fonction *) (*(*l_element_courant)
2273: .donnee).objet)).nombre_arguments == 1))
2274: {
2275: if (depilement(s_etat_processus, &((*s_etat_processus)
2276: .l_base_pile), &s_objet_indice_i) == d_erreur)
2277: {
2278: free(s_objet_elementaire);
2279:
2280: if (presence_variable_partagee == d_vrai)
2281: {
2282: (*s_etat_processus).s_liste_variables
2283: [(*s_etat_processus)
2284: .position_variable_courante].objet
2285: = NULL;
2286:
2287: if (pthread_mutex_unlock(
2288: &((*(*s_etat_processus)
2289: .s_liste_variables_partagees)
2290: .mutex)) != 0)
2291: {
2292: (*s_etat_processus).erreur_systeme =
2293: d_es_processus;
2294: }
2295: }
2296:
2297: if (presence_egalite == d_vrai)
2298: {
2299: liberation(s_etat_processus, s_objet_evalue);
2300: }
2301:
2302: (*s_etat_processus).erreur_execution =
2303: d_ex_manque_argument;
2304: (*s_etat_processus).instruction_courante =
2305: instruction_courante;
2306: (*s_etat_processus).mode_execution_programme =
2307: registre_mode_execution_programme;
2308: return(d_erreur);
2309: }
2310:
2311: if ((*s_objet_indice_i).type != INT)
2312: {
2313: liberation(s_etat_processus, s_objet_indice_i);
2314: free(s_objet_elementaire);
2315:
2316: if (presence_variable_partagee == d_vrai)
2317: {
2318: (*s_etat_processus).s_liste_variables
2319: [(*s_etat_processus)
2320: .position_variable_courante].objet
2321: = NULL;
2322:
2323: if (pthread_mutex_unlock(
2324: &((*(*s_etat_processus)
2325: .s_liste_variables_partagees)
2326: .mutex)) != 0)
2327: {
2328: (*s_etat_processus).erreur_systeme =
2329: d_es_processus;
2330: }
2331: }
2332:
2333: if (presence_egalite == d_vrai)
2334: {
2335: liberation(s_etat_processus, s_objet_evalue);
2336: }
2337:
2338: (*s_etat_processus).erreur_execution =
2339: d_ex_erreur_type_argument;
2340: (*s_etat_processus).instruction_courante =
2341: instruction_courante;
2342: (*s_etat_processus).mode_execution_programme =
2343: registre_mode_execution_programme;
2344: return(d_erreur);
2345: }
2346:
2347: i = (*((integer8 *) (*s_objet_indice_i).objet));
2348:
2349: liberation(s_etat_processus, s_objet_indice_i);
2350:
2351: l_sous_element_courant = (*(((*s_etat_processus)
2352: .s_liste_variables[(*s_etat_processus)
2353: .position_variable_courante]).objet)).objet;
2354: j = 0;
2355:
2356: while(l_sous_element_courant != NULL)
2357: {
2358: if ((++j) == i)
2359: {
2360: break;
2361: }
2362:
2363: l_sous_element_courant =
2364: (*l_sous_element_courant).suivant;
2365: }
2366:
2367: if (j != i)
2368: {
2369: free(s_objet_elementaire);
2370:
2371: if (presence_variable_partagee == d_vrai)
2372: {
2373: (*s_etat_processus).s_liste_variables
2374: [(*s_etat_processus)
2375: .position_variable_courante].objet
2376: = NULL;
2377:
2378: if (pthread_mutex_unlock(
2379: &((*(*s_etat_processus)
2380: .s_liste_variables_partagees)
2381: .mutex)) != 0)
2382: {
2383: (*s_etat_processus).erreur_systeme =
2384: d_es_processus;
2385: }
2386: }
2387:
2388: if (presence_egalite == d_vrai)
2389: {
2390: liberation(s_etat_processus, s_objet_evalue);
2391: }
2392:
2393: (*s_etat_processus).erreur_execution =
2394: d_ex_element_inexistant;
2395: (*s_etat_processus).instruction_courante =
2396: instruction_courante;
2397: (*s_etat_processus).mode_execution_programme =
2398: registre_mode_execution_programme;
2399: return(d_erreur);
2400: }
2401:
2402: free(s_objet_elementaire);
2403:
2404: if ((s_objet_elementaire =
2405: copie_objet(s_etat_processus,
2406: (*l_sous_element_courant).donnee, 'P')) == NULL)
2407: {
2408: if (presence_variable_partagee == d_vrai)
2409: {
2410: (*s_etat_processus).s_liste_variables
2411: [(*s_etat_processus)
2412: .position_variable_courante].objet
2413: = NULL;
2414:
2415: if (pthread_mutex_unlock(
2416: &((*(*s_etat_processus)
2417: .s_liste_variables_partagees)
2418: .mutex)) != 0)
2419: {
2420: (*s_etat_processus).erreur_systeme =
2421: d_es_processus;
2422: }
2423: }
2424:
2425: if (presence_egalite == d_vrai)
2426: {
2427: liberation(s_etat_processus, s_objet_evalue);
2428: }
2429:
2430: (*s_etat_processus).erreur_systeme =
2431: d_es_allocation_memoire;
2432: (*s_etat_processus).instruction_courante =
2433: instruction_courante;
2434: return(d_erreur);
2435: }
2436: }
2437:
2438: /*
2439: * Recherche de l'élément idoine dans la table
2440: */
2441:
2442: else if (((*(((*s_etat_processus).s_liste_variables
2443: [(*s_etat_processus).position_variable_courante])
2444: .objet)).type == TAB) &&
2445: ((*((struct_fonction *) (*(*l_element_courant)
2446: .donnee).objet)).nombre_arguments == 1))
2447: {
2448: if (depilement(s_etat_processus, &((*s_etat_processus)
2449: .l_base_pile), &s_objet_indice_i) == d_erreur)
2450: {
2451: free(s_objet_elementaire);
2452:
2453: if (presence_variable_partagee == d_vrai)
2454: {
2455: (*s_etat_processus).s_liste_variables
2456: [(*s_etat_processus)
2457: .position_variable_courante].objet
2458: = NULL;
2459:
2460: if (pthread_mutex_unlock(
2461: &((*(*s_etat_processus)
2462: .s_liste_variables_partagees)
2463: .mutex)) != 0)
2464: {
2465: (*s_etat_processus).erreur_systeme =
2466: d_es_processus;
2467: }
2468: }
2469:
2470: if (presence_egalite == d_vrai)
2471: {
2472: liberation(s_etat_processus, s_objet_evalue);
2473: }
2474:
2475: (*s_etat_processus).erreur_execution =
2476: d_ex_manque_argument;
2477: (*s_etat_processus).instruction_courante =
2478: instruction_courante;
2479: (*s_etat_processus).mode_execution_programme =
2480: registre_mode_execution_programme;
2481: return(d_erreur);
2482: }
2483:
2484: if ((*s_objet_indice_i).type != INT)
2485: {
2486: liberation(s_etat_processus, s_objet_indice_i);
2487: free(s_objet_elementaire);
2488:
2489: if (presence_variable_partagee == d_vrai)
2490: {
2491: (*s_etat_processus).s_liste_variables
2492: [(*s_etat_processus)
2493: .position_variable_courante].objet
2494: = NULL;
2495:
2496: if (pthread_mutex_unlock(
2497: &((*(*s_etat_processus)
2498: .s_liste_variables_partagees)
2499: .mutex)) != 0)
2500: {
2501: (*s_etat_processus).erreur_systeme =
2502: d_es_processus;
2503: }
2504: }
2505:
2506: if (presence_egalite == d_vrai)
2507: {
2508: liberation(s_etat_processus, s_objet_evalue);
2509: }
2510:
2511: (*s_etat_processus).erreur_execution =
2512: d_ex_erreur_type_argument;
2513: (*s_etat_processus).instruction_courante =
2514: instruction_courante;
2515: (*s_etat_processus).mode_execution_programme =
2516: registre_mode_execution_programme;
2517: return(d_erreur);
2518: }
2519:
2520: i = (*((integer8 *) (*s_objet_indice_i).objet));
2521:
2522: liberation(s_etat_processus, s_objet_indice_i);
2523:
2524: if ((i < 1) || (i > (integer8) (*((struct_tableau *)
2525: (*((*s_etat_processus).s_liste_variables
2526: [(*s_etat_processus)
2527: .position_variable_courante]).objet)
2528: .objet)).nombre_elements))
2529: {
2530: free(s_objet_elementaire);
2531:
2532: if (presence_variable_partagee == d_vrai)
2533: {
2534: (*s_etat_processus).s_liste_variables
2535: [(*s_etat_processus)
2536: .position_variable_courante].objet
2537: = NULL;
2538:
2539: if (pthread_mutex_unlock(
2540: &((*(*s_etat_processus)
2541: .s_liste_variables_partagees)
2542: .mutex)) != 0)
2543: {
2544: (*s_etat_processus).erreur_systeme =
2545: d_es_processus;
2546: }
2547: }
2548:
2549: if (presence_egalite == d_vrai)
2550: {
2551: liberation(s_etat_processus, s_objet_evalue);
2552: }
2553:
2554: (*s_etat_processus).erreur_execution =
2555: d_ex_element_inexistant;
2556: (*s_etat_processus).instruction_courante =
2557: instruction_courante;
2558: (*s_etat_processus).mode_execution_programme =
2559: registre_mode_execution_programme;
2560: return(d_erreur);
2561: }
2562:
2563: free(s_objet_elementaire);
2564:
2565: if ((s_objet_elementaire =
2566: copie_objet(s_etat_processus,
2567: (*((struct_tableau *) (*((*s_etat_processus)
2568: .s_liste_variables[(*s_etat_processus)
2569: .position_variable_courante]).objet)
2570: .objet)).elements[i - 1], 'P')) == NULL)
2571: {
2572: if (presence_variable_partagee == d_vrai)
2573: {
2574: (*s_etat_processus).s_liste_variables
2575: [(*s_etat_processus)
2576: .position_variable_courante].objet
2577: = NULL;
2578:
2579: if (pthread_mutex_unlock(
2580: &((*(*s_etat_processus)
2581: .s_liste_variables_partagees)
2582: .mutex)) != 0)
2583: {
2584: (*s_etat_processus).erreur_systeme =
2585: d_es_processus;
2586: }
2587: }
2588:
2589: if (presence_egalite == d_vrai)
2590: {
2591: liberation(s_etat_processus, s_objet_evalue);
2592: }
2593:
2594: (*s_etat_processus).erreur_systeme =
2595: d_es_allocation_memoire;
2596: (*s_etat_processus).instruction_courante =
2597: instruction_courante;
2598: return(d_erreur);
2599: }
2600: }
2601: else if (((*(((*s_etat_processus).s_liste_variables
2602: [(*s_etat_processus).position_variable_courante])
2603: .objet)).type == ALG) ||
2604: ((*(((*s_etat_processus).s_liste_variables
2605: [(*s_etat_processus).position_variable_courante])
2606: .objet)).type == RPN))
2607: {
2608: registre_evaluation_expression_compilee =
2609: (*s_etat_processus)
2610: .evaluation_expression_compilee;
2611:
2612: if (((*s_etat_processus).s_liste_variables
2613: [(*s_etat_processus)
2614: .position_variable_courante].origine == 'E') &&
2615: ((*s_etat_processus).s_liste_variables
2616: [(*s_etat_processus).position_variable_courante]
2617: .niveau == 0))
2618: {
2619: (*s_etat_processus).evaluation_expression_compilee =
2620: 'Y';
2621: }
2622: else
2623: {
2624: (*s_etat_processus).evaluation_expression_compilee =
2625: 'N';
2626: }
2627:
2628: if (evaluation(s_etat_processus, (*s_etat_processus)
2629: .s_liste_variables[(*s_etat_processus)
2630: .position_variable_courante].objet,
2631: type_evaluation) == d_erreur)
2632: {
2633: (*s_etat_processus).evaluation_expression_compilee =
2634: registre_evaluation_expression_compilee;
2635:
2636: if (presence_variable_partagee == d_vrai)
2637: {
2638: (*s_etat_processus).s_liste_variables
2639: [(*s_etat_processus)
2640: .position_variable_courante].objet
2641: = NULL;
2642:
2643: if (pthread_mutex_unlock(
2644: &((*(*s_etat_processus)
2645: .s_liste_variables_partagees)
2646: .mutex)) != 0)
2647: {
2648: (*s_etat_processus).erreur_systeme =
2649: d_es_processus;
2650: }
2651: }
2652:
2653: if (presence_egalite == d_vrai)
2654: {
2655: liberation(s_etat_processus, s_objet_evalue);
2656: }
2657:
2658: (*s_etat_processus).instruction_courante =
2659: instruction_courante;
2660: (*s_etat_processus).mode_execution_programme =
2661: registre_mode_execution_programme;
2662: return(d_erreur);
2663: }
2664:
2665: (*s_etat_processus).evaluation_expression_compilee =
2666: registre_evaluation_expression_compilee;
2667:
2668: free(s_objet_elementaire);
2669:
2670: if (depilement(s_etat_processus, &((*s_etat_processus)
2671: .l_base_pile), &s_objet_elementaire)
2672: == d_erreur)
2673: {
2674: if (presence_variable_partagee == d_vrai)
2675: {
2676: (*s_etat_processus).s_liste_variables
2677: [(*s_etat_processus)
2678: .position_variable_courante].objet
2679: = NULL;
2680:
2681: if (pthread_mutex_unlock(
2682: &((*(*s_etat_processus)
2683: .s_liste_variables_partagees)
2684: .mutex)) != 0)
2685: {
2686: (*s_etat_processus).erreur_systeme =
2687: d_es_processus;
2688: }
2689: }
2690:
2691: if (presence_egalite == d_vrai)
2692: {
2693: liberation(s_etat_processus, s_objet_evalue);
2694: }
2695:
2696: (*s_etat_processus).erreur_execution =
2697: d_ex_manque_argument;
2698: (*s_etat_processus).instruction_courante =
2699: instruction_courante;
2700: (*s_etat_processus).mode_execution_programme =
2701: registre_mode_execution_programme;
2702: return(d_erreur);
2703: }
2704: }
2705: else if ((*(((*s_etat_processus).s_liste_variables
2706: [(*s_etat_processus).position_variable_courante])
2707: .objet)).type == ADR)
2708: {
2709: autorisation_empilement_programme = (*s_etat_processus)
2710: .autorisation_empilement_programme;
2711: registre_position_courante = (*s_etat_processus)
2712: .position_courante;
2713:
2714: empilement_pile_systeme(s_etat_processus);
2715:
2716: if ((*s_etat_processus).erreur_systeme != d_es)
2717: {
2718: if (presence_variable_partagee == d_vrai)
2719: {
2720: (*s_etat_processus).s_liste_variables
2721: [(*s_etat_processus)
2722: .position_variable_courante].objet
2723: = NULL;
2724:
2725: if (pthread_mutex_unlock(
2726: &((*(*s_etat_processus)
2727: .s_liste_variables_partagees)
2728: .mutex)) != 0)
2729: {
2730: (*s_etat_processus).erreur_systeme =
2731: d_es_processus;
2732: }
2733: }
2734:
2735: if (presence_egalite == d_vrai)
2736: {
2737: liberation(s_etat_processus, s_objet_evalue);
2738: }
2739:
2740: (*s_etat_processus).instruction_courante =
2741: instruction_courante;
2742: return(d_erreur);
2743: }
2744:
2745: (*(*s_etat_processus).l_base_pile_systeme)
2746: .retour_definition = 'Y';
2747: (*(*s_etat_processus).l_base_pile_systeme)
2748: .origine_routine_evaluation = 'Y';
2749:
2750: (*s_etat_processus).mode_execution_programme = 'Y';
2751: (*s_etat_processus).autorisation_empilement_programme
2752: = 'N';
2753:
2754: (*(*s_etat_processus).l_base_pile_systeme)
2755: .niveau_courant = (*s_etat_processus)
2756: .niveau_courant;
2757:
2758: (*s_etat_processus).position_courante =
2759: (*((unsigned long *)
2760: ((*((*s_etat_processus).s_liste_variables
2761: [(*s_etat_processus)
2762: .position_variable_courante]
2763: .objet)).objet)));
2764:
2765: if ((*s_etat_processus).profilage == d_vrai)
2766: {
2767: profilage(s_etat_processus,
2768: (*s_etat_processus).s_liste_variables
2769: [(*s_etat_processus)
2770: .position_variable_courante].nom);
2771:
2772: if ((*s_etat_processus).erreur_systeme != d_es)
2773: {
2774: if (presence_variable_partagee == d_vrai)
2775: {
2776: (*s_etat_processus).s_liste_variables
2777: [(*s_etat_processus)
2778: .position_variable_courante].objet
2779: = NULL;
2780:
2781: if (pthread_mutex_unlock(
2782: &((*(*s_etat_processus)
2783: .s_liste_variables_partagees)
2784: .mutex)) != 0)
2785: {
2786: (*s_etat_processus).erreur_systeme =
2787: d_es_processus;
2788: }
2789: }
2790:
2791: return(d_erreur);
2792: }
2793: }
2794:
2795: if (sequenceur(s_etat_processus) == d_erreur)
2796: {
2797: if (presence_variable_partagee == d_vrai)
2798: {
2799: (*s_etat_processus).s_liste_variables
2800: [(*s_etat_processus)
2801: .position_variable_courante].objet
2802: = NULL;
2803:
2804: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2805: .s_liste_variables_partagees)
2806: .mutex)) != 0)
2807: {
2808: (*s_etat_processus).erreur_systeme =
2809: d_es_processus;
2810: }
2811: }
2812:
2813: if (presence_egalite == d_vrai)
2814: {
2815: liberation(s_etat_processus, s_objet_evalue);
2816: }
2817:
2818: (*s_etat_processus).instruction_courante =
2819: instruction_courante;
2820: (*s_etat_processus).mode_execution_programme =
2821: registre_mode_execution_programme;
2822: return(d_erreur);
2823: }
2824:
2825: (*s_etat_processus).instruction_courante =
2826: instruction_courante;
2827: (*s_etat_processus).mode_execution_programme = 'N';
2828:
2829: depilement_pile_systeme(s_etat_processus);
2830:
2831: if ((*s_etat_processus).erreur_systeme != d_es)
2832: {
2833: if (presence_variable_partagee == d_vrai)
2834: {
2835: (*s_etat_processus).s_liste_variables
2836: [(*s_etat_processus)
2837: .position_variable_courante].objet
2838: = NULL;
2839:
2840: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2841: .s_liste_variables_partagees)
2842: .mutex)) != 0)
2843: {
2844: (*s_etat_processus).erreur_systeme =
2845: d_es_processus;
2846: }
2847: }
2848:
2849: if (presence_egalite == d_vrai)
2850: {
2851: liberation(s_etat_processus, s_objet_evalue);
2852: }
2853:
2854: return(d_erreur);
2855: }
2856:
2857: (*s_etat_processus).retour_routine_evaluation = 'N';
2858: (*s_etat_processus).position_courante =
2859: registre_position_courante;
2860: (*s_etat_processus).autorisation_empilement_programme =
2861: autorisation_empilement_programme;
2862:
2863: free(s_objet_elementaire);
2864:
2865: if (depilement(s_etat_processus, &((*s_etat_processus)
2866: .l_base_pile), &s_objet_elementaire)
2867: == d_erreur)
2868: {
2869: if (presence_variable_partagee == d_vrai)
2870: {
2871: (*s_etat_processus).s_liste_variables
2872: [(*s_etat_processus)
2873: .position_variable_courante].objet
2874: = NULL;
2875:
2876: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2877: .s_liste_variables_partagees).mutex))
2878: != 0)
2879: {
2880: (*s_etat_processus).erreur_systeme =
2881: d_es_processus;
2882: }
2883: }
2884:
2885: if (presence_egalite == d_vrai)
2886: {
2887: liberation(s_etat_processus, s_objet_evalue);
2888: }
2889:
2890: (*s_etat_processus).erreur_execution =
2891: d_ex_manque_argument;
2892: (*s_etat_processus).instruction_courante =
2893: instruction_courante;
2894: (*s_etat_processus).mode_execution_programme =
2895: registre_mode_execution_programme;
2896: return(d_erreur);
2897: }
2898: }
2899: else
2900: {
2901: if (presence_variable_partagee == d_vrai)
2902: {
2903: (*s_etat_processus).s_liste_variables
2904: [(*s_etat_processus)
2905: .position_variable_courante].objet
2906: = NULL;
2907:
2908: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2909: .s_liste_variables_partagees) .mutex)) != 0)
2910: {
2911: (*s_etat_processus).erreur_systeme =
2912: d_es_processus;
2913: }
2914: }
2915:
2916: if (presence_egalite == d_vrai)
2917: {
2918: liberation(s_etat_processus, s_objet_evalue);
2919: }
2920:
2921: (*s_etat_processus).erreur_execution =
2922: d_ex_element_inexistant;
2923: (*s_etat_processus).instruction_courante =
2924: instruction_courante;
2925: (*s_etat_processus).mode_execution_programme =
2926: registre_mode_execution_programme;
2927:
2928: return(d_erreur);
2929: }
2930:
2931: if (empilement(s_etat_processus, &((*s_etat_processus)
2932: .l_base_pile), s_objet_elementaire) == d_erreur)
2933: {
2934: if (presence_variable_partagee == d_vrai)
2935: {
2936: (*s_etat_processus).s_liste_variables
2937: [(*s_etat_processus)
2938: .position_variable_courante].objet
2939: = NULL;
2940:
2941: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2942: .s_liste_variables_partagees).mutex)) != 0)
2943: {
2944: (*s_etat_processus).erreur_systeme =
2945: d_es_processus;
2946: }
2947: }
2948:
2949: if (presence_egalite == d_vrai)
2950: {
2951: liberation(s_etat_processus, s_objet_evalue);
2952: }
2953:
2954: (*s_etat_processus).instruction_courante =
2955: instruction_courante;
2956: return(d_erreur);
2957: }
2958:
2959: if (presence_variable_partagee == d_vrai)
2960: {
2961: (*s_etat_processus).s_liste_variables
2962: [(*s_etat_processus)
2963: .position_variable_courante].objet
2964: = NULL;
2965:
2966: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2967: .s_liste_variables_partagees).mutex)) != 0)
2968: {
2969: (*s_etat_processus).erreur_systeme =
2970: d_es_processus;
2971: }
2972: }
2973: }
2974: }
2975: else if (((*(*l_element_courant).donnee).type == ALG)
2976: || ((*(*l_element_courant).donnee).type == RPN))
2977: {
2978: if (type_evaluation == 'I')
2979: {
2980: if ((s_objet_elementaire = copie_objet(s_etat_processus,
2981: (*l_element_courant).donnee, 'P')) == NULL)
2982: {
2983: if (presence_egalite == d_vrai)
2984: {
2985: liberation(s_etat_processus, s_objet_evalue);
2986: }
2987:
2988: (*s_etat_processus).erreur_systeme =
2989: d_es_allocation_memoire;
2990: (*s_etat_processus).instruction_courante =
2991: instruction_courante;
2992: return(d_erreur);
2993: }
2994:
2995: if (empilement(s_etat_processus, &((*s_etat_processus)
2996: .l_base_pile), s_objet_elementaire)
2997: == d_erreur)
2998: {
2999: if (presence_egalite == d_vrai)
3000: {
3001: liberation(s_etat_processus, s_objet_evalue);
3002: }
3003:
3004: (*s_etat_processus).instruction_courante =
3005: instruction_courante;
3006: return(d_erreur);
3007: }
3008: }
3009: else
3010: {
3011: if ((*s_etat_processus).autorisation_empilement_programme
3012: == 'N')
3013: {
3014: registre_evaluation_expression_compilee =
3015: (*s_etat_processus)
3016: .evaluation_expression_compilee;
3017:
3018: (*s_etat_processus).evaluation_expression_compilee
3019: = 'N';
3020:
3021: if (evaluation(s_etat_processus, (*l_element_courant)
3022: .donnee, type_evaluation) == d_erreur)
3023: {
3024: (*s_etat_processus).evaluation_expression_compilee
3025: = registre_evaluation_expression_compilee;
3026:
3027: if (presence_egalite == d_vrai)
3028: {
3029: liberation(s_etat_processus, s_objet_evalue);
3030: }
3031:
3032: (*s_etat_processus).instruction_courante =
3033: instruction_courante;
3034: (*s_etat_processus).mode_execution_programme =
3035: registre_mode_execution_programme;
3036: return(d_erreur);
3037: }
3038:
3039: (*s_etat_processus).evaluation_expression_compilee
3040: = registre_evaluation_expression_compilee;
3041: }
3042: else
3043: {
3044: if ((s_objet_elementaire =
3045: copie_objet(s_etat_processus,
3046: (*l_element_courant).donnee, 'P')) == NULL)
3047: {
3048: if (presence_egalite == d_vrai)
3049: {
3050: liberation(s_etat_processus, s_objet_evalue);
3051: }
3052:
3053: (*s_etat_processus).erreur_systeme =
3054: d_es_allocation_memoire;
3055: (*s_etat_processus).instruction_courante =
3056: instruction_courante;
3057: return(d_erreur);
3058: }
3059:
3060: if (empilement(s_etat_processus, &((*s_etat_processus)
3061: .l_base_pile), s_objet_elementaire)
3062: == d_erreur)
3063: {
3064: if (presence_egalite == d_vrai)
3065: {
3066: liberation(s_etat_processus, s_objet_evalue);
3067: }
3068:
3069: (*s_etat_processus).instruction_courante =
3070: instruction_courante;
3071: return(d_erreur);
3072: }
3073: }
3074: }
3075: }
3076: else if ((*(*l_element_courant).donnee).type == NOM)
3077: {
3078: registre_instruction_valide = (*s_etat_processus)
3079: .instruction_valide;
3080: registre_test = (*s_etat_processus).test_instruction;
3081: (*s_etat_processus).test_instruction = 'Y';
3082: (*s_etat_processus).instruction_courante = (*((struct_nom *)
3083: (*(*l_element_courant).donnee).objet)).nom;
3084:
3085: analyse(s_etat_processus, NULL);
3086:
3087: (*s_etat_processus).test_instruction = 'N';
3088:
3089: if ((*s_etat_processus).instruction_valide == 'Y')
3090: {
3091: registre_test_2 = (*s_etat_processus).test_instruction;
3092: (*s_etat_processus).test_instruction = 'N';
3093:
3094: analyse(s_etat_processus, NULL);
3095:
3096: (*s_etat_processus).test_instruction = registre_test_2;
3097: }
3098: else if ((*s_etat_processus).constante_symbolique == 'N')
3099: {
3100: if ((s_objet_elementaire = copie_objet(s_etat_processus,
3101: (*l_element_courant).donnee, 'P')) == NULL)
3102: {
3103: if (presence_egalite == d_vrai)
3104: {
3105: liberation(s_etat_processus, s_objet_evalue);
3106: }
3107:
3108: (*s_etat_processus).erreur_systeme =
3109: d_es_allocation_memoire;
3110: (*s_etat_processus).instruction_courante =
3111: instruction_courante;
3112: return(d_erreur);
3113: }
3114:
3115: presence_fonction = d_faux;
3116: presence_variable_partagee = d_faux;
3117:
3118: if (recherche_variable(s_etat_processus, (*((struct_nom *)
3119: (*s_objet_elementaire).objet)).nom) == d_faux)
3120: {
3121: (*s_etat_processus).erreur_systeme = d_es;
3122: presence_variable = d_faux;
3123: }
3124: else
3125: {
3126: if ((*s_etat_processus).traitement_symbolique == 'N')
3127: {
3128: if ((*s_etat_processus).s_liste_variables
3129: [(*s_etat_processus)
3130: .position_variable_courante].objet == NULL)
3131: {
3132: // Variable partagée
3133:
3134: if (pthread_mutex_lock(&((*(*s_etat_processus)
3135: .s_liste_variables_partagees).mutex))
3136: != 0)
3137: {
3138: (*s_etat_processus).erreur_systeme =
3139: d_es_processus;
3140: return(d_erreur);
3141: }
3142:
3143: presence_variable_partagee = d_faux;
3144:
3145: if (recherche_variable_partagee(
3146: s_etat_processus,
3147: ((*s_etat_processus).s_liste_variables
3148: [(*s_etat_processus)
3149: .position_variable_courante]).nom,
3150: ((*s_etat_processus).s_liste_variables
3151: [(*s_etat_processus)
3152: .position_variable_courante])
3153: .variable_partagee, 'E') == d_vrai)
3154: {
3155: presence_variable = d_vrai;
3156: presence_variable_partagee = d_vrai;
3157:
3158: if ((*((*(*s_etat_processus)
3159: .s_liste_variables_partagees).table
3160: [(*(*s_etat_processus)
3161: .s_liste_variables_partagees)
3162: .position_variable].objet)).type
3163: == ADR)
3164: {
3165: presence_fonction = d_vrai;
3166: }
3167:
3168: if ((type_evaluation == 'N') ||
3169: ((*((struct_nom *)
3170: (*(*l_element_courant).donnee)
3171: .objet)).symbole == d_faux))
3172: {
3173: if ((s_copie_variable_partagee =
3174: copie_objet(s_etat_processus,
3175: (*(*s_etat_processus)
3176: .s_liste_variables_partagees)
3177: .table[(*(*s_etat_processus)
3178: .s_liste_variables_partagees)
3179: .position_variable].objet, 'P'))
3180: == NULL)
3181: {
3182: if (pthread_mutex_unlock(
3183: &((*(*s_etat_processus)
3184: .s_liste_variables_partagees
3185: ).mutex)) != 0)
3186: {
3187: (*s_etat_processus)
3188: .erreur_systeme =
3189: d_es_processus;
3190: return(d_erreur);
3191: }
3192: }
3193: }
3194: else
3195: {
3196: s_copie_variable_partagee = NULL;
3197: }
3198:
3199: if (pthread_mutex_unlock(
3200: &((*(*s_etat_processus)
3201: .s_liste_variables_partagees)
3202: .mutex)) != 0)
3203: {
3204: (*s_etat_processus).erreur_systeme =
3205: d_es_processus;
3206: return(d_erreur);
3207: }
3208: }
3209: else
3210: {
3211: (*s_etat_processus).erreur_systeme = d_es;
3212: presence_variable = d_faux;
3213: presence_variable_partagee = d_faux;
3214:
3215: if (pthread_mutex_unlock(
3216: &((*(*s_etat_processus)
3217: .s_liste_variables_partagees)
3218: .mutex)) != 0)
3219: {
3220: (*s_etat_processus).erreur_systeme =
3221: d_es_processus;
3222: return(d_erreur);
3223: }
3224: }
3225: }
3226: else
3227: {
3228: presence_variable = d_vrai;
3229:
3230: if ((*((*s_etat_processus)
3231: .s_liste_variables
3232: [(*s_etat_processus)
3233: .position_variable_courante]
3234: .objet)).type == ADR)
3235: {
3236: presence_fonction = d_vrai;
3237: }
3238: }
3239: }
3240: else
3241: {
3242: presence_variable = d_faux;
3243: }
3244: }
3245:
3246: liberation(s_etat_processus, s_objet_elementaire);
3247:
3248: if (presence_fonction == d_vrai)
3249: {
3250: autorisation_empilement_programme = (*s_etat_processus)
3251: .autorisation_empilement_programme;
3252: registre_position_courante = (*s_etat_processus)
3253: .position_courante;
3254:
3255: empilement_pile_systeme(s_etat_processus);
3256:
3257: if ((*s_etat_processus).erreur_systeme != d_es)
3258: {
3259: if (presence_variable_partagee == d_vrai)
3260: {
3261: liberation(s_etat_processus,
3262: s_copie_variable_partagee);
3263: }
3264:
3265: if (presence_egalite == d_vrai)
3266: {
3267: liberation(s_etat_processus, s_objet_evalue);
3268: }
3269:
3270: (*s_etat_processus).instruction_courante =
3271: instruction_courante;
3272: return(d_erreur);
3273: }
3274:
3275: (*(*s_etat_processus).l_base_pile_systeme)
3276: .retour_definition = 'Y';
3277: (*(*s_etat_processus).l_base_pile_systeme)
3278: .origine_routine_evaluation = 'Y';
3279:
3280: (*s_etat_processus).mode_execution_programme = 'Y';
3281: (*s_etat_processus).autorisation_empilement_programme
3282: = 'N';
3283:
3284: (*(*s_etat_processus).l_base_pile_systeme)
3285: .niveau_courant = (*s_etat_processus)
3286: .niveau_courant;
3287:
3288: if (presence_variable_partagee == d_faux)
3289: {
3290: (*s_etat_processus).position_courante =
3291: (*((unsigned long *)
3292: ((*((*s_etat_processus).s_liste_variables
3293: [(*s_etat_processus)
3294: .position_variable_courante]
3295: .objet)).objet)));
3296: }
3297: else
3298: {
3299: (*s_etat_processus).position_courante =
3300: (*((unsigned long *)
3301: (*s_copie_variable_partagee).objet));
3302: liberation(s_etat_processus,
3303: s_copie_variable_partagee);
3304: }
3305:
3306: if ((*s_etat_processus).profilage == d_vrai)
3307: {
3308: profilage(s_etat_processus,
3309: (*s_etat_processus).s_liste_variables
3310: [(*s_etat_processus)
3311: .position_variable_courante].nom);
3312:
3313: if ((*s_etat_processus).erreur_systeme != d_es)
3314: {
3315: return(d_erreur);
3316: }
3317: }
3318:
3319: if (sequenceur(s_etat_processus) == d_erreur)
3320: {
3321: if (presence_egalite == d_vrai)
3322: {
3323: liberation(s_etat_processus, s_objet_evalue);
3324: }
3325:
3326: (*s_etat_processus).instruction_courante =
3327: instruction_courante;
3328: (*s_etat_processus).mode_execution_programme =
3329: registre_mode_execution_programme;
3330: return(d_erreur);
3331: }
3332:
3333: (*s_etat_processus).instruction_courante =
3334: instruction_courante;
3335: (*s_etat_processus).mode_execution_programme = 'N';
3336:
3337: depilement_pile_systeme(s_etat_processus);
3338:
3339: if ((*s_etat_processus).erreur_systeme != d_es)
3340: {
3341: if (presence_egalite == d_vrai)
3342: {
3343: liberation(s_etat_processus, s_objet_evalue);
3344: }
3345:
3346: return(d_erreur);
3347: }
3348:
3349: (*s_etat_processus).retour_routine_evaluation = 'N';
3350: (*s_etat_processus).position_courante =
3351: registre_position_courante;
3352: (*s_etat_processus).autorisation_empilement_programme =
3353: autorisation_empilement_programme;
3354: }
3355: else if (((type_evaluation == 'N') || ((*((struct_nom *)
3356: (*(*l_element_courant).donnee).objet)).symbole ==
3357: d_faux)) && (presence_variable == d_vrai))
3358: {
3359: if (type_evaluation == 'I')
3360: {
3361: if (presence_variable_partagee == d_faux)
3362: {
3363: if ((s_sous_objet =
3364: copie_objet(s_etat_processus,
3365: (*s_etat_processus)
3366: .s_liste_variables[(*s_etat_processus)
3367: .position_variable_courante].objet,
3368: 'P')) == NULL)
3369: {
3370: if (presence_variable_partagee == d_vrai)
3371: {
3372: liberation(s_etat_processus,
3373: s_copie_variable_partagee);
3374: }
3375:
3376: if (presence_egalite == d_vrai)
3377: {
3378: liberation(s_etat_processus,
3379: s_objet_evalue);
3380: }
3381:
3382: (*s_etat_processus).erreur_systeme =
3383: d_es_allocation_memoire;
3384: (*s_etat_processus).instruction_courante =
3385: instruction_courante;
3386: return(d_erreur);
3387: }
3388:
3389: if (empilement(s_etat_processus,
3390: &((*s_etat_processus).l_base_pile),
3391: s_sous_objet) == d_erreur)
3392: {
3393: if (presence_variable_partagee == d_vrai)
3394: {
3395: liberation(s_etat_processus,
3396: s_copie_variable_partagee);
3397: }
3398:
3399: if (presence_egalite == d_vrai)
3400: {
3401: liberation(s_etat_processus,
3402: s_objet_evalue);
3403: }
3404:
3405: return(d_erreur);
3406: }
3407: }
3408: else
3409: {
3410: if (empilement(s_etat_processus,
3411: &((*s_etat_processus).l_base_pile),
3412: s_copie_variable_partagee) == d_erreur)
3413: {
3414: if (presence_variable_partagee == d_vrai)
3415: {
3416: liberation(s_etat_processus,
3417: s_copie_variable_partagee);
3418: }
3419:
3420: if (presence_egalite == d_vrai)
3421: {
3422: liberation(s_etat_processus,
3423: s_objet_evalue);
3424: }
3425:
3426: return(d_erreur);
3427: }
3428: }
3429: }
3430: else
3431: {
3432: registre_evaluation_expression_compilee =
3433: (*s_etat_processus)
3434: .evaluation_expression_compilee;
3435:
3436: if (((*s_etat_processus).s_liste_variables
3437: [(*s_etat_processus)
3438: .position_variable_courante].origine == 'E')
3439: && ((*s_etat_processus).s_liste_variables
3440: [(*s_etat_processus)
3441: .position_variable_courante].niveau == 0))
3442: {
3443: (*s_etat_processus)
3444: .evaluation_expression_compilee = 'Y';
3445: }
3446: else
3447: {
3448: (*s_etat_processus)
3449: .evaluation_expression_compilee = 'N';
3450: }
3451:
3452: if (presence_variable_partagee == d_faux)
3453: {
3454: if ((*s_etat_processus).profilage == d_vrai)
3455: {
3456: profilage(s_etat_processus,
3457: (*s_etat_processus)
3458: .s_liste_variables
3459: [(*s_etat_processus)
3460: .position_variable_courante].nom);
3461:
3462: if ((*s_etat_processus).erreur_systeme
3463: != d_es)
3464: {
3465: return(d_erreur);
3466: }
3467: }
3468:
3469: registre_niveau_courant = (*(*s_etat_processus)
3470: .l_base_pile_systeme).niveau_courant;
3471: registre_retour_definition =
3472: (*(*s_etat_processus)
3473: .l_base_pile_systeme).retour_definition;
3474:
3475: (*(*s_etat_processus).l_base_pile_systeme)
3476: .retour_definition = 'Y';
3477: (*(*s_etat_processus).l_base_pile_systeme)
3478: .niveau_courant = (*s_etat_processus)
3479: .niveau_courant;
3480: empilement_pile_systeme(s_etat_processus);
3481:
3482: if (evaluation(s_etat_processus,
3483: (*s_etat_processus)
3484: .s_liste_variables[(*s_etat_processus)
3485: .position_variable_courante].objet,
3486: type_evaluation) == d_erreur)
3487: {
3488: depilement_pile_systeme(s_etat_processus);
3489:
3490: (*(*s_etat_processus).l_base_pile_systeme)
3491: .niveau_courant =
3492: (*(*s_etat_processus).l_base_pile_systeme)
3493: .retour_definition =
3494: registre_retour_definition;
3495:
3496: if ((*s_etat_processus).profilage == d_vrai)
3497: {
3498: profilage(s_etat_processus, NULL);
3499: }
3500:
3501: (*s_etat_processus)
3502: .evaluation_expression_compilee =
3503: registre_evaluation_expression_compilee;
3504:
3505: if (presence_egalite == d_vrai)
3506: {
3507: liberation(s_etat_processus,
3508: s_objet_evalue);
3509: }
3510:
3511: (*s_etat_processus).instruction_courante =
3512: instruction_courante;
3513: (*s_etat_processus).mode_execution_programme
3514: = registre_mode_execution_programme;
3515: return(d_erreur);
3516: }
3517:
3518: depilement_pile_systeme(s_etat_processus);
3519:
3520: (*(*s_etat_processus).l_base_pile_systeme)
3521: .niveau_courant =
3522: (*(*s_etat_processus).l_base_pile_systeme)
3523: .retour_definition =
3524: registre_retour_definition;
3525: }
3526: else
3527: {
3528: if ((*s_etat_processus).profilage == d_vrai)
3529: {
3530: profilage(s_etat_processus,
3531: (*s_etat_processus)
3532: .s_liste_variables
3533: [(*s_etat_processus)
3534: .position_variable_courante].nom);
3535:
3536: if ((*s_etat_processus).erreur_systeme
3537: != d_es)
3538: {
3539: return(d_erreur);
3540: }
3541: }
3542:
3543: empilement_pile_systeme(s_etat_processus);
3544: (*(*s_etat_processus).l_base_pile_systeme)
3545: .retour_definition = 'Y';
3546: (*(*s_etat_processus).l_base_pile_systeme)
3547: .niveau_courant = (*s_etat_processus)
3548: .niveau_courant;
3549: empilement_pile_systeme(s_etat_processus);
3550:
3551: if (evaluation(s_etat_processus,
3552: s_copie_variable_partagee,
3553: type_evaluation) == d_erreur)
3554: {
3555: depilement_pile_systeme(s_etat_processus);
3556: depilement_pile_systeme(s_etat_processus);
3557:
3558: liberation(s_etat_processus,
3559: s_copie_variable_partagee);
3560:
3561: if ((*s_etat_processus).profilage == d_vrai)
3562: {
3563: profilage(s_etat_processus, NULL);
3564: }
3565:
3566: (*s_etat_processus)
3567: .evaluation_expression_compilee =
3568: registre_evaluation_expression_compilee;
3569:
3570: if (presence_egalite == d_vrai)
3571: {
3572: liberation(s_etat_processus,
3573: s_objet_evalue);
3574: }
3575:
3576: (*s_etat_processus).instruction_courante =
3577: instruction_courante;
3578: (*s_etat_processus).mode_execution_programme
3579: = registre_mode_execution_programme;
3580: return(d_erreur);
3581: }
3582:
3583: depilement_pile_systeme(s_etat_processus);
3584: depilement_pile_systeme(s_etat_processus);
3585:
3586: liberation(s_etat_processus,
3587: s_copie_variable_partagee);
3588: }
3589:
3590: if ((*s_etat_processus).profilage == d_vrai)
3591: {
3592: profilage(s_etat_processus, NULL);
3593: }
3594:
3595: (*s_etat_processus)
3596: .evaluation_expression_compilee =
3597: registre_evaluation_expression_compilee;
3598: }
3599: }
3600: else
3601: {
3602: if (presence_variable_partagee == d_vrai)
3603: {
3604: liberation(s_etat_processus,
3605: s_copie_variable_partagee);
3606: }
3607:
3608: if ((s_objet_elementaire =
3609: copie_objet(s_etat_processus,
3610: (*l_element_courant).donnee, 'P')) == NULL)
3611: {
3612: if (presence_egalite == d_vrai)
3613: {
3614: liberation(s_etat_processus, s_objet_evalue);
3615: }
3616:
3617: (*s_etat_processus).erreur_systeme =
3618: d_es_allocation_memoire;
3619: (*s_etat_processus).instruction_courante =
3620: instruction_courante;
3621: return(d_erreur);
3622: }
3623:
3624: /*
3625: * Vérification du drapeau symbole pour
3626: * savoir si l'on met dans la pile le nom
3627: * ou le contenu de la variable.
3628: */
3629:
3630: if (((*((struct_nom *) (*s_objet_elementaire).objet))
3631: .symbole == d_faux) && ((*s_etat_processus)
3632: .traitement_symbolique == 'N'))
3633: {
3634: if (recherche_variable(s_etat_processus,
3635: (*((struct_nom *) (*s_objet_elementaire)
3636: .objet)).nom) == d_vrai)
3637: {
3638: if ((*s_etat_processus).s_liste_variables
3639: [(*s_etat_processus)
3640: .position_variable_courante].objet
3641: == NULL)
3642: {
3643: // Variable partagée
3644:
3645: if (pthread_mutex_lock(
3646: &((*(*s_etat_processus)
3647: .s_liste_variables_partagees)
3648: .mutex)) != 0)
3649: {
3650: (*s_etat_processus).erreur_systeme =
3651: d_es_processus;
3652: return(d_erreur);
3653: }
3654:
3655: if (recherche_variable_partagee(
3656: s_etat_processus,
3657: ((*s_etat_processus)
3658: .s_liste_variables
3659: [(*s_etat_processus)
3660: .position_variable_courante]).nom,
3661: ((*s_etat_processus)
3662: .s_liste_variables
3663: [(*s_etat_processus)
3664: .position_variable_courante])
3665: .variable_partagee, 'E') == d_vrai)
3666: {
3667: liberation(s_etat_processus,
3668: s_objet_elementaire);
3669:
3670: if ((s_objet_elementaire =
3671: copie_objet(s_etat_processus,
3672: (*(*s_etat_processus)
3673: .s_liste_variables_partagees)
3674: .table[(*(*s_etat_processus)
3675: .s_liste_variables_partagees)
3676: .position_variable].objet,
3677: 'P')) == NULL)
3678: {
3679: if (pthread_mutex_unlock(
3680: &((*(*s_etat_processus)
3681: .s_liste_variables_partagees
3682: ).mutex)) != 0)
3683: {
3684: (*s_etat_processus)
3685: .erreur_systeme =
3686: d_es_processus;
3687: return(d_erreur);
3688: }
3689:
3690: if (presence_egalite == d_vrai)
3691: {
3692: liberation(s_etat_processus,
3693: s_objet_evalue);
3694: }
3695:
3696: (*s_etat_processus).erreur_systeme =
3697: d_es_allocation_memoire;
3698: (*s_etat_processus)
3699: .instruction_courante =
3700: instruction_courante;
3701: return(d_erreur);
3702: }
3703: }
3704:
3705: if (pthread_mutex_unlock(
3706: &((*(*s_etat_processus)
3707: .s_liste_variables_partagees)
3708: .mutex)) != 0)
3709: {
3710: (*s_etat_processus).erreur_systeme =
3711: d_es_processus;
3712: return(d_erreur);
3713: }
3714: }
3715: else
3716: {
3717: // Variable privée
3718:
3719: liberation(s_etat_processus,
3720: s_objet_elementaire);
3721:
3722: if ((s_objet_elementaire =
3723: copie_objet(s_etat_processus,
3724: (*s_etat_processus)
3725: .s_liste_variables
3726: [(*s_etat_processus)
3727: .position_variable_courante].objet,
3728: 'P')) == NULL)
3729: {
3730: if (presence_egalite == d_vrai)
3731: {
3732: liberation(s_etat_processus,
3733: s_objet_evalue);
3734: }
3735:
3736: (*s_etat_processus).erreur_systeme =
3737: d_es_allocation_memoire;
3738: (*s_etat_processus)
3739: .instruction_courante =
3740: instruction_courante;
3741: return(d_erreur);
3742: }
3743: }
3744: }
3745: else
3746: {
3747: (*s_etat_processus).erreur_systeme = d_es;
3748:
3749: (*((struct_nom *) (*s_objet_elementaire)
3750: .objet)).symbole = d_vrai;
3751: }
3752: }
3753:
3754: if (empilement(s_etat_processus, &((*s_etat_processus)
3755: .l_base_pile), s_objet_elementaire) == d_erreur)
3756: {
3757: if (presence_egalite == d_vrai)
3758: {
3759: liberation(s_etat_processus, s_objet_evalue);
3760: }
3761:
3762: (*s_etat_processus).instruction_courante =
3763: instruction_courante;
3764: return(d_erreur);
3765: }
3766:
3767: if ((*s_etat_processus).erreur_execution ==
3768: d_ex_variable_non_definie)
3769: {
3770: (*s_etat_processus).erreur_execution = d_ex;
3771: }
3772: }
3773: }
3774: else
3775: {
3776: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
3777: == d_vrai) ? 'E' : 'N';
3778:
3779: if (type_evaluation == 'N')
3780: {
3781: cf(s_etat_processus, 35);
3782: }
3783: else
3784: {
3785: sf(s_etat_processus, 35);
3786: }
3787:
3788: analyse(s_etat_processus, NULL);
3789:
3790: if (registre_type_evaluation == 'E')
3791: {
3792: sf(s_etat_processus, 35);
3793: }
3794: else
3795: {
3796: cf(s_etat_processus, 35);
3797: }
3798:
3799: if (((*s_etat_processus).erreur_systeme != d_es) ||
3800: ((*s_etat_processus).erreur_execution != d_ex) ||
3801: ((*s_etat_processus).exception != d_ep))
3802: {
3803: if (presence_egalite == d_vrai)
3804: {
3805: liberation(s_etat_processus, s_objet_evalue);
3806: }
3807:
3808: (*s_etat_processus).instruction_courante =
3809: instruction_courante;
3810: (*s_etat_processus).mode_execution_programme =
3811: registre_mode_execution_programme;
3812: return(d_erreur);
3813: }
3814: }
3815:
3816: (*s_etat_processus).instruction_courante =
3817: instruction_courante;
3818: (*s_etat_processus).test_instruction = registre_test;
3819: (*s_etat_processus).instruction_valide =
3820: registre_instruction_valide;
3821: }
3822: else
3823: {
3824: if ((s_objet_tampon = copie_objet(s_etat_processus,
3825: (*l_element_courant).donnee, 'P')) == NULL)
3826: {
3827: (*s_etat_processus).erreur_systeme =
3828: d_es_allocation_memoire;
3829: (*s_etat_processus).instruction_courante =
3830: instruction_courante;
3831: return(d_erreur);
3832: }
3833:
3834: if (empilement(s_etat_processus, &((*s_etat_processus)
3835: .l_base_pile), s_objet_tampon) == d_erreur)
3836: {
3837: if (presence_egalite == d_vrai)
3838: {
3839: liberation(s_etat_processus, s_objet_evalue);
3840: }
3841:
3842: (*s_etat_processus).instruction_courante =
3843: instruction_courante;
3844: return(d_erreur);
3845: }
3846: }
3847:
3848: // Traitement de l'instruction EXIT en mode interactif
3849:
3850: if (l_element_courant != NULL)
3851: {
3852: l_element_courant = (*l_element_courant).suivant;
3853: }
3854: else
3855: {
3856: (*s_etat_processus).mode_execution_programme = 'Y';
3857:
3858: if ((*s_etat_processus).niveau_courant == 1)
3859: {
3860: (*s_etat_processus).debug_programme = d_faux;
3861: (*s_etat_processus).execution_pas_suivant = d_vrai;
3862: }
3863: }
3864:
3865: if ((*s_etat_processus).traitement_cycle_exit != 'N')
3866: {
3867: registre_expression_courante =
3868: (*s_etat_processus).expression_courante;
3869: (*s_etat_processus).expression_courante =
3870: l_element_courant;
3871:
3872: switch((*s_etat_processus).traitement_cycle_exit)
3873: {
3874: case 'C' :
3875: {
3876: instruction_cycle(s_etat_processus);
3877: break;
3878: }
3879:
3880: case 'E' :
3881: {
3882: instruction_exit(s_etat_processus);
3883: break;
3884: }
3885: }
3886:
3887: l_element_courant = (*s_etat_processus).expression_courante;
3888: (*s_etat_processus).expression_courante =
3889: registre_expression_courante;
3890: }
3891: }
3892:
3893: if (niveau_initial < (*s_etat_processus).niveau_courant)
3894: {
3895: /*
3896: * Retrait des variables dans le cas où l'évaluation de
3897: * l'expression a été interrompue
3898: */
3899:
3900: (*s_etat_processus).niveau_courant = niveau_initial;
3901:
3902: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
3903: {
3904: if ((*s_etat_processus).s_liste_variables[n].niveau
3905: > niveau_initial)
3906: {
3907: m++;
3908: }
3909: }
3910:
3911: registre_variables = (*s_etat_processus).s_liste_variables;
3912: (*s_etat_processus).nombre_variables -= m;
3913:
3914: if (((*s_etat_processus).s_liste_variables = malloc(
3915: (*s_etat_processus).nombre_variables *
3916: sizeof(struct_variable))) == NULL)
3917: {
3918: if (presence_egalite == d_vrai)
3919: {
3920: liberation(s_etat_processus, s_objet_evalue);
3921: }
3922:
3923: (*s_etat_processus).instruction_courante = instruction_courante;
3924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3925: return(d_erreur);
3926: }
3927:
3928: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
3929: {
3930: if (registre_variables[n + m].niveau > niveau_initial)
3931: {
3932: free(registre_variables[n + m].nom);
3933: liberation(s_etat_processus,
3934: registre_variables[n + m].objet);
3935: m++;
3936: n--;
3937: }
3938: else
3939: {
3940: (*s_etat_processus).s_liste_variables[n] =
3941: registre_variables[n + m];
3942: }
3943: }
3944:
3945: free(registre_variables);
3946: }
3947:
3948: /*
3949: * Retrait des variables statiques créées dans l'expression
3950: */
3951:
3952: for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
3953: {
3954: if ((*s_etat_processus).s_liste_variables_statiques[n]
3955: .niveau > (*s_etat_processus).niveau_courant)
3956: {
3957: if (retrait_variable_statique(s_etat_processus,
3958: (*s_etat_processus).s_liste_variables_statiques[n].nom,
3959: (*s_etat_processus).s_liste_variables_statiques[n]
3960: .variable_statique) == d_erreur)
3961: {
3962: if (presence_egalite == d_vrai)
3963: {
3964: liberation(s_etat_processus, s_objet_evalue);
3965: }
3966:
3967: (*s_etat_processus).instruction_courante =
3968: instruction_courante;
3969: (*s_etat_processus).mode_execution_programme =
3970: registre_mode_execution_programme;
3971: return(d_erreur);
3972: }
3973: }
3974: }
3975:
3976: /*
3977: * Retrait des variables partagées créées dans l'expression
3978: */
3979:
3980: if (pthread_mutex_lock(&((*(*s_etat_processus)
3981: .s_liste_variables_partagees).mutex)) != 0)
3982: {
3983: (*s_etat_processus).erreur_systeme = d_es_processus;
3984: return(d_erreur);
3985: }
3986:
3987: for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
3988: .nombre_variables; n++)
3989: {
3990: if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
3991: .niveau > (*s_etat_processus).niveau_courant)
3992: {
3993: if (retrait_variable_partagee(s_etat_processus,
3994: (*(*s_etat_processus).s_liste_variables_partagees)
3995: .table[n].nom, (*(*s_etat_processus)
3996: .s_liste_variables_partagees).table[n]
3997: .variable_partagee) == d_erreur)
3998: {
3999: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4000: .s_liste_variables_partagees).mutex)) != 0)
4001: {
4002: (*s_etat_processus).erreur_systeme = d_es_processus;
4003: return(d_erreur);
4004: }
4005:
4006: if (presence_egalite == d_vrai)
4007: {
4008: liberation(s_etat_processus, s_objet_evalue);
4009: }
4010:
4011: (*s_etat_processus).instruction_courante =
4012: instruction_courante;
4013: (*s_etat_processus).mode_execution_programme =
4014: registre_mode_execution_programme;
4015: return(d_erreur);
4016: }
4017: }
4018: }
4019:
4020: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4021: .s_liste_variables_partagees).mutex)) != 0)
4022: {
4023: (*s_etat_processus).erreur_systeme = d_es_processus;
4024: return(d_erreur);
4025: }
4026:
4027: if ((*s_etat_processus).var_volatile_requete_arret != 0)
4028: {
4029: // Restauration de la pile système
4030:
4031: while(pile_systeme_originelle !=
4032: (*s_etat_processus).l_base_pile_systeme)
4033: {
4034: depilement_pile_systeme(s_etat_processus);
4035: }
4036: }
4037:
4038: if (presence_egalite == d_vrai)
4039: {
4040: // Ajout du membre évalué lors de la première passe
4041:
4042: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
4043: s_objet_evalue) == d_erreur)
4044: {
4045: (*s_etat_processus).instruction_courante =
4046: instruction_courante;
4047: return(d_erreur);
4048: }
4049:
4050: instruction_swap(s_etat_processus);
4051:
4052: if ((*s_etat_processus).erreur_execution != d_ex)
4053: {
4054: (*s_etat_processus).mode_execution_programme =
4055: registre_mode_execution_programme;
4056: (*s_etat_processus).autorisation_empilement_programme =
4057: autorisation_empilement_programme;
4058: (*s_etat_processus).instruction_courante = instruction_courante;
4059: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
4060: registre_retour_definition;
4061:
4062: return(d_erreur);
4063: }
4064:
4065: instruction_egalite(s_etat_processus);
4066:
4067: if ((*s_etat_processus).erreur_execution != d_ex)
4068: {
4069: (*s_etat_processus).mode_execution_programme =
4070: registre_mode_execution_programme;
4071: (*s_etat_processus).autorisation_empilement_programme =
4072: autorisation_empilement_programme;
4073: (*s_etat_processus).instruction_courante = instruction_courante;
4074: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
4075: registre_retour_definition;
4076:
4077: return(d_erreur);
4078: }
4079: }
4080:
4081: (*s_etat_processus).autorisation_empilement_programme =
4082: autorisation_empilement_programme;
4083: (*s_etat_processus).instruction_courante = instruction_courante;
4084: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
4085: registre_retour_definition;
4086: }
4087: else if ((*s_objet).type == FCT)
4088: {
4089: (*s_etat_processus).instruction_courante =
4090: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
4091:
4092: analyse(s_etat_processus, (*((struct_fonction *)
4093: (*s_objet).objet)).fonction);
4094:
4095: (*s_etat_processus).instruction_courante = instruction_courante;
4096:
4097: if (((*s_etat_processus).erreur_systeme != d_es) ||
4098: ((*s_etat_processus).erreur_execution != d_ex) ||
4099: ((*s_etat_processus).exception != d_ep))
4100: {
4101: (*s_etat_processus).instruction_courante = instruction_courante;
4102: (*s_etat_processus).mode_execution_programme =
4103: registre_mode_execution_programme;
4104: return(d_erreur);
4105: }
4106: }
4107: else
4108: {
4109: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
4110: == NULL)
4111: {
4112: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4113: (*s_etat_processus).instruction_courante = instruction_courante;
4114: return(d_erreur);
4115: }
4116:
4117: if (empilement(s_etat_processus, &((*s_etat_processus)
4118: .l_base_pile), s_objet_tampon) == d_erreur)
4119: {
4120: (*s_etat_processus).instruction_courante = instruction_courante;
4121: return(d_erreur);
4122: }
4123: }
4124:
4125: (*s_etat_processus).mode_execution_programme =
4126: registre_mode_execution_programme;
4127:
4128: return((erreur_evaluation == d_absence_erreur)
4129: ? d_absence_erreur : d_erreur);
4130: }
4131:
4132: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src