![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to evaluation.c CVS log | Up to [local] / rpl / src |
Ajout de la fonction alsprintf() dans formateur().
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.10
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: if ((*s_etat_processus)
868: .erreur_systeme != d_es)
869: {
870: (*s_etat_processus)
871: .instruction_courante =
872: instruction_courante;
873: return(d_erreur);
874: }
875:
876: (*s_etat_processus).exception
877: = registre_exception;
878: (*s_etat_processus)
879: .erreur_execution =
880: registre_erreur_execution;
881: }
882: else
883: {
884: empilement_pile_systeme(
885: s_etat_processus);
886:
887: if ((*s_etat_processus)
888: .erreur_systeme != d_es)
889: {
890: if (presence_egalite ==
891: d_vrai)
892: {
893: liberation(
894: s_etat_processus,
895: s_objet_evalue);
896: }
897:
898: (*s_etat_processus)
899: .instruction_courante =
900: instruction_courante;
901: return(d_erreur);
902: }
903: }
904: }
905: else if (TEST(instruction_end) ||
906: TEST(instruction_next) ||
907: TEST(instruction_step) ||
908: TEST(vers_niveau_inferieur))
909: {
910: if (TEST(vers_niveau_inferieur))
911: {
912: registre_exception =
913: (*s_etat_processus)
914: .exception;
915: registre_erreur_execution =
916: (*s_etat_processus)
917: .erreur_execution;
918:
919: analyse(s_etat_processus,
920: vers_niveau_inferieur);
921:
922: if ((*s_etat_processus)
923: .erreur_systeme != d_es)
924: {
925: (*s_etat_processus)
926: .instruction_courante =
927: instruction_courante;
928: return(d_erreur);
929: }
930:
931: (*s_etat_processus).exception
932: = registre_exception;
933: (*s_etat_processus)
934: .erreur_execution =
935: registre_erreur_execution;
936: }
937: else
938: {
939: depilement_pile_systeme(
940: s_etat_processus);
941:
942: if ((*s_etat_processus)
943: .erreur_systeme != d_es)
944: {
945: if (presence_egalite ==
946: d_vrai)
947: {
948: liberation(
949: s_etat_processus,
950: s_objet_evalue);
951: }
952:
953: (*s_etat_processus)
954: .instruction_courante =
955: instruction_courante;
956: return(d_erreur);
957: }
958: }
959: }
960: }
961: }
962: }
963:
964: (*s_etat_processus).instruction_courante =
965: instruction_courante;
966: drapeau_then = d_faux;
967:
968: do
969: {
970: l_registre_atome = l_element_courant;
971:
972: if (l_element_courant == NULL)
973: {
974: /*
975: * La fin de l'expression est atteinte,
976: * le sequenceur reprend la main.
977: */
978:
979: if (presence_egalite == d_vrai)
980: {
981: liberation(s_etat_processus,
982: s_objet_evalue);
983: }
984:
985: (*s_etat_processus)
986: .mode_execution_programme =
987: registre_mode_execution_programme;
988: (*s_etat_processus).instruction_courante =
989: instruction_courante;
990: return(d_absence_erreur);
991: }
992:
993: if ((*(*l_element_courant).donnee).type == FCT)
994: {
995: (*s_etat_processus)
996: .instruction_courante =
997: (*((struct_fonction *)
998: (*(*l_element_courant).donnee)
999: .objet)).nom_fonction;
1000: fonction = (*((struct_fonction *)
1001: (*(*l_element_courant).donnee)
1002: .objet)).fonction;
1003: (*s_etat_processus).instruction_courante =
1004: instruction_courante;
1005:
1006: drapeau_then = TEST(instruction_then)
1007: ? d_vrai : d_faux;
1008: }
1009:
1010: l_element_courant = (*l_element_courant)
1011: .suivant;
1012: } while(drapeau_then == d_faux);
1013:
1014: (*s_etat_processus).expression_courante =
1015: l_registre_atome;
1016:
1017: (*(*s_etat_processus).l_base_pile_systeme)
1018: .clause = 'X';
1019: instruction_then(s_etat_processus);
1020:
1021: (*s_etat_processus).exception = d_ep;
1022: (*s_etat_processus).erreur_execution = d_ex;
1023: }
1024: else if ((*s_etat_processus).mode_evaluation_expression
1025: == 'Y')
1026: {
1027: /*
1028: * Reprise sur erreur
1029: */
1030:
1031: while(l_element_courant != NULL)
1032: {
1033: if ((*(*l_element_courant).donnee).type == FCT)
1034: {
1035: (*s_etat_processus).instruction_courante =
1036: (*((struct_fonction *)
1037: (*(*l_element_courant).donnee)
1038: .objet)).nom_fonction;
1039: fonction = (*((struct_fonction *)
1040: (*(*l_element_courant).donnee)
1041: .objet)).fonction;
1042:
1043: if (recherche_variable(s_etat_processus,
1044: (*s_etat_processus)
1045: .instruction_courante) == d_faux)
1046: {
1047: (*s_etat_processus).erreur_systeme
1048: = d_es;
1049:
1050: /*
1051: * Traitement de la pile système par les
1052: * différentes instructions.
1053: */
1054:
1055: if (TEST(instruction_if) ||
1056: TEST(instruction_iferr) ||
1057: TEST(instruction_do) ||
1058: TEST(instruction_while) ||
1059: TEST(instruction_for) ||
1060: TEST(instruction_start) ||
1061: TEST(instruction_select) ||
1062: TEST(instruction_case) ||
1063: TEST(vers_niveau_superieur))
1064: {
1065: if (TEST(vers_niveau_superieur))
1066: {
1067: analyse(s_etat_processus,
1068: vers_niveau_superieur);
1069:
1070: if ((*s_etat_processus)
1071: .erreur_systeme != d_es)
1072: {
1073: (*s_etat_processus)
1074: .instruction_courante =
1075: instruction_courante;
1076: return(d_erreur);
1077: }
1078: }
1079: else
1080: {
1081: empilement_pile_systeme(
1082: s_etat_processus);
1083:
1084: if ((*s_etat_processus)
1085: .erreur_systeme != d_es)
1086: {
1087: if (presence_egalite ==
1088: d_vrai)
1089: {
1090: liberation(
1091: s_etat_processus,
1092: s_objet_evalue);
1093: }
1094:
1095: (*s_etat_processus)
1096: .instruction_courante =
1097: instruction_courante;
1098: return(d_erreur);
1099: }
1100: }
1101: }
1102: else if (TEST(instruction_end) ||
1103: TEST(instruction_next) ||
1104: TEST(instruction_step) ||
1105: TEST(vers_niveau_inferieur))
1106: {
1107: if (TEST(vers_niveau_inferieur))
1108: {
1109: analyse(s_etat_processus,
1110: vers_niveau_inferieur);
1111:
1112: if ((*s_etat_processus)
1113: .erreur_systeme != d_es)
1114: {
1115: (*s_etat_processus)
1116: .instruction_courante =
1117: instruction_courante;
1118: return(d_erreur);
1119: }
1120: }
1121: else
1122: {
1123: depilement_pile_systeme(
1124: s_etat_processus);
1125:
1126: if ((*s_etat_processus)
1127: .erreur_systeme != d_es)
1128: {
1129: if (presence_egalite ==
1130: d_vrai)
1131: {
1132: liberation(
1133: s_etat_processus,
1134: s_objet_evalue);
1135: }
1136:
1137: (*s_etat_processus)
1138: .instruction_courante =
1139: instruction_courante;
1140: return(d_erreur);
1141: }
1142: }
1143: }
1144: }
1145: }
1146:
1147: l_element_courant =
1148: (*l_element_courant).suivant;
1149: }
1150:
1151: (*s_etat_processus).mode_execution_programme =
1152: registre_mode_execution_programme;
1153: (*s_etat_processus).instruction_courante =
1154: instruction_courante;
1155:
1156: (*s_etat_processus).exception = d_ep;
1157: (*s_etat_processus).erreur_execution = d_ex;
1158:
1159: erreur_evaluation = d_erreur;
1160:
1161: (*s_etat_processus).expression_courante =
1162: registre_expression_courante;
1163: }
1164: else
1165: {
1166: // On ne détruit pas les variables pour les inclure
1167: // dans le fichier rpl-core.
1168:
1169: (*s_etat_processus).gel_liste_variables = d_vrai;
1170:
1171: registre_erreur_execution =
1172: (*s_etat_processus).erreur_execution;
1173: registre_exception =
1174: (*s_etat_processus).exception;
1175: registre_erreur_systeme =
1176: (*s_etat_processus).erreur_systeme;
1177:
1178: (*s_etat_processus).s_objet_errone = s_objet;
1179: (*s_etat_processus).s_objet_erreur =
1180: (*l_element_courant).donnee;
1181:
1182: l_element_courant = (*l_element_courant).suivant;
1183:
1184: while(l_element_courant != NULL)
1185: {
1186: if ((*(*l_element_courant).donnee).type == FCT)
1187: {
1188: (*s_etat_processus).instruction_courante =
1189: (*((struct_fonction *)
1190: (*(*l_element_courant).donnee)
1191: .objet)).nom_fonction;
1192: fonction = (*((struct_fonction *)
1193: (*(*l_element_courant).donnee)
1194: .objet)).fonction;
1195:
1196: if (recherche_variable(s_etat_processus,
1197: (*s_etat_processus)
1198: .instruction_courante) == d_faux)
1199: {
1200: (*s_etat_processus).erreur_systeme
1201: = d_es;
1202:
1203: /*
1204: * Traitement de la pile système par les
1205: * différentes instructions.
1206: */
1207:
1208: if (TEST(instruction_if) ||
1209: TEST(instruction_iferr) ||
1210: TEST(instruction_do) ||
1211: TEST(instruction_while) ||
1212: TEST(instruction_for) ||
1213: TEST(instruction_start) ||
1214: TEST(instruction_select) ||
1215: TEST(instruction_case) ||
1216: TEST(vers_niveau_superieur))
1217: {
1218: if (TEST(vers_niveau_superieur))
1219: {
1220: analyse(s_etat_processus,
1221: vers_niveau_superieur);
1222:
1223: if ((*s_etat_processus)
1224: .erreur_systeme != d_es)
1225: {
1226: (*s_etat_processus)
1227: .instruction_courante =
1228: instruction_courante;
1229: return(d_erreur);
1230: }
1231: }
1232: else
1233: {
1234: empilement_pile_systeme(
1235: s_etat_processus);
1236:
1237: if ((*s_etat_processus)
1238: .erreur_systeme != d_es)
1239: {
1240: if (presence_egalite ==
1241: d_vrai)
1242: {
1243: liberation(
1244: s_etat_processus,
1245: s_objet_evalue);
1246: }
1247:
1248: (*s_etat_processus)
1249: .instruction_courante =
1250: instruction_courante;
1251: return(d_erreur);
1252: }
1253: }
1254: }
1255: else if (TEST(instruction_end) ||
1256: TEST(instruction_next) ||
1257: TEST(instruction_step) ||
1258: TEST(vers_niveau_inferieur))
1259: {
1260: if (TEST(vers_niveau_inferieur))
1261: {
1262: analyse(s_etat_processus,
1263: vers_niveau_inferieur);
1264:
1265: if ((*s_etat_processus)
1266: .erreur_systeme != d_es)
1267: {
1268: (*s_etat_processus)
1269: .instruction_courante =
1270: instruction_courante;
1271: return(d_erreur);
1272: }
1273: }
1274: else
1275: {
1276: depilement_pile_systeme(
1277: s_etat_processus);
1278:
1279: if ((*s_etat_processus)
1280: .erreur_systeme != d_es)
1281: {
1282: if (presence_egalite ==
1283: d_vrai)
1284: {
1285: liberation(
1286: s_etat_processus,
1287: s_objet_evalue);
1288: }
1289:
1290: (*s_etat_processus)
1291: .instruction_courante =
1292: instruction_courante;
1293: return(d_erreur);
1294: }
1295: }
1296: }
1297: }
1298: }
1299:
1300: l_element_courant =
1301: (*l_element_courant).suivant;
1302: }
1303:
1304: (*s_etat_processus).mode_execution_programme =
1305: registre_mode_execution_programme;
1306: (*s_etat_processus).instruction_courante =
1307: instruction_courante;
1308:
1309: if (presence_egalite == d_vrai)
1310: {
1311: liberation(s_etat_processus, s_objet_evalue);
1312: }
1313:
1314: if ((*s_etat_processus)
1315: .var_volatile_processus_pere == 0)
1316: {
1317: kill((*s_etat_processus)
1318: .pid_processus_pere, SIGALRM);
1319: }
1320: else
1321: {
1322: (*s_etat_processus).var_volatile_alarme = -1;
1323: }
1324:
1325: (*s_etat_processus).erreur_execution =
1326: registre_erreur_execution;
1327: (*s_etat_processus).erreur_systeme =
1328: registre_erreur_systeme;
1329: (*s_etat_processus).exception =
1330: registre_exception;
1331: return(d_erreur);
1332: }
1333: }
1334:
1335: if ((*s_etat_processus).instruction_valide == 'Y')
1336: {
1337: l_element_courant = (*s_etat_processus)
1338: .expression_courante;
1339: }
1340: else
1341: {
1342: /*
1343: * Régénération de la fonction en notation algébrique
1344: */
1345:
1346: if ((s_objet_elementaire = (struct_objet *)
1347: allocation(s_etat_processus, ALG)) == NULL)
1348: {
1349: if (presence_egalite == d_vrai)
1350: {
1351: liberation(s_etat_processus, s_objet_evalue);
1352: }
1353:
1354: (*s_etat_processus).erreur_systeme =
1355: d_es_allocation_memoire;
1356: (*s_etat_processus).instruction_courante =
1357: instruction_courante;
1358: return(d_erreur);
1359: }
1360:
1361: /*
1362: * Ouverture de l'expression
1363: */
1364:
1365: if (((*s_objet_elementaire).objet =
1366: (struct_liste_chainee *)
1367: malloc(sizeof(struct_liste_chainee))) == NULL)
1368: {
1369: if (presence_egalite == d_vrai)
1370: {
1371: liberation(s_etat_processus, s_objet_evalue);
1372: }
1373:
1374: (*s_etat_processus).erreur_systeme =
1375: d_es_allocation_memoire;
1376: (*s_etat_processus).instruction_courante =
1377: instruction_courante;
1378: return(d_erreur);
1379: }
1380:
1381: l_element_fonction = (*s_objet_elementaire).objet;
1382:
1383: if (((*l_element_fonction).donnee = (struct_objet *)
1384: allocation(s_etat_processus, FCT)) == NULL)
1385: {
1386: if (presence_egalite == d_vrai)
1387: {
1388: liberation(s_etat_processus, s_objet_evalue);
1389: }
1390:
1391: (*s_etat_processus).erreur_systeme =
1392: d_es_allocation_memoire;
1393: (*s_etat_processus).instruction_courante =
1394: instruction_courante;
1395: return(d_erreur);
1396: }
1397:
1398: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1399: .objet)).nombre_arguments = 0;
1400: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1401: .objet)).fonction =
1402: instruction_vers_niveau_superieur;
1403:
1404: if (((*((struct_fonction *) (*(*l_element_fonction)
1405: .donnee).objet)).nom_fonction =
1406: (unsigned char *) malloc(3 * sizeof(
1407: unsigned char))) == NULL)
1408: {
1409: if (presence_egalite == d_vrai)
1410: {
1411: liberation(s_etat_processus, s_objet_evalue);
1412: }
1413:
1414: (*s_etat_processus).erreur_systeme =
1415: d_es_allocation_memoire;
1416: (*s_etat_processus).instruction_courante =
1417: instruction_courante;
1418: return(d_erreur);
1419: }
1420:
1421: strcpy((*((struct_fonction *) (*(*l_element_fonction)
1422: .donnee).objet)).nom_fonction, "<<");
1423:
1424: /*
1425: * Ajout des arguments
1426: */
1427:
1428: for(k = (*((struct_fonction *)
1429: (*(*l_element_courant).donnee).objet))
1430: .nombre_arguments; k >= 1; k--)
1431: {
1432: if (((*l_element_fonction).suivant =
1433: (struct_liste_chainee *) malloc(sizeof(
1434: struct_liste_chainee))) == NULL)
1435: {
1436: if (presence_egalite == d_vrai)
1437: {
1438: liberation(s_etat_processus,
1439: s_objet_evalue);
1440: }
1441:
1442: (*s_etat_processus).erreur_systeme =
1443: d_es_allocation_memoire;
1444: (*s_etat_processus).instruction_courante =
1445: instruction_courante;
1446: return(d_erreur);
1447: }
1448:
1449: l_element_fonction = (*l_element_fonction).suivant;
1450:
1451: if (k > 1)
1452: {
1453: l_liste1 = (*s_etat_processus).l_base_pile;
1454:
1455: for(l = 2; l < k; l++)
1456: {
1457: l_liste1 = (*l_liste1).suivant;
1458: }
1459:
1460: l_liste2 = (*l_liste1).suivant;
1461: (*l_liste1).suivant = (*l_liste2).suivant;
1462: (*l_liste2).suivant = (*s_etat_processus)
1463: .l_base_pile;
1464: (*s_etat_processus).l_base_pile = l_liste2;
1465: }
1466:
1467: if (depilement(s_etat_processus,
1468: &((*s_etat_processus).l_base_pile),
1469: &s_sous_objet) == d_erreur)
1470: {
1471: if (presence_egalite == d_vrai)
1472: {
1473: liberation(s_etat_processus,
1474: s_objet_evalue);
1475: }
1476:
1477: (*s_etat_processus).erreur_execution =
1478: d_ex_manque_argument;
1479: (*s_etat_processus).instruction_courante =
1480: instruction_courante;
1481: (*s_etat_processus).mode_execution_programme =
1482: registre_mode_execution_programme;
1483: return(d_erreur);
1484: }
1485:
1486: (*l_element_fonction).donnee = s_sous_objet;
1487: }
1488:
1489: /*
1490: * Ajout de la fonction
1491: */
1492:
1493: if (((*l_element_fonction).suivant =
1494: (struct_liste_chainee *) malloc(sizeof(
1495: struct_liste_chainee))) == NULL)
1496: {
1497: if (presence_egalite == d_vrai)
1498: {
1499: liberation(s_etat_processus, s_objet_evalue);
1500: }
1501:
1502: (*s_etat_processus).erreur_systeme =
1503: d_es_allocation_memoire;
1504: (*s_etat_processus).instruction_courante =
1505: instruction_courante;
1506: return(d_erreur);
1507: }
1508:
1509: l_element_fonction = (*l_element_fonction).suivant;
1510:
1511: if (((*l_element_fonction).donnee =
1512: copie_objet(s_etat_processus,
1513: (*l_element_courant).donnee, 'P'))
1514: == NULL)
1515: {
1516: if (presence_egalite == d_vrai)
1517: {
1518: liberation(s_etat_processus, s_objet_evalue);
1519: }
1520:
1521: (*s_etat_processus).erreur_systeme =
1522: d_es_allocation_memoire;
1523: (*s_etat_processus).instruction_courante =
1524: instruction_courante;
1525: return(d_erreur);
1526: }
1527:
1528: /*
1529: * Clôture de l'expression
1530: */
1531:
1532: if (((*l_element_fonction).suivant =
1533: (struct_liste_chainee *) malloc(sizeof(
1534: struct_liste_chainee))) == NULL)
1535: {
1536: if (presence_egalite == d_vrai)
1537: {
1538: liberation(s_etat_processus, s_objet_evalue);
1539: }
1540:
1541: (*s_etat_processus).erreur_systeme =
1542: d_es_allocation_memoire;
1543: (*s_etat_processus).instruction_courante =
1544: instruction_courante;
1545: return(d_erreur);
1546: }
1547:
1548: l_element_fonction = (*l_element_fonction).suivant;
1549:
1550: if (((*l_element_fonction).donnee =
1551: allocation(s_etat_processus, FCT)) == NULL)
1552: {
1553: if (presence_egalite == d_vrai)
1554: {
1555: liberation(s_etat_processus, s_objet_evalue);
1556: }
1557:
1558: (*s_etat_processus).erreur_systeme =
1559: d_es_allocation_memoire;
1560: (*s_etat_processus).instruction_courante =
1561: instruction_courante;
1562: return(d_erreur);
1563: }
1564:
1565: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1566: .objet)).nombre_arguments = 0;
1567: (*((struct_fonction *) (*(*l_element_fonction).donnee)
1568: .objet)).fonction =
1569: instruction_vers_niveau_inferieur;
1570:
1571: if (((*((struct_fonction *) (*(*l_element_fonction)
1572: .donnee).objet)).nom_fonction =
1573: (unsigned char *) malloc(3 * sizeof(
1574: unsigned char))) == NULL)
1575: {
1576: if (presence_egalite == d_vrai)
1577: {
1578: liberation(s_etat_processus, s_objet_evalue);
1579: }
1580:
1581: (*s_etat_processus).erreur_systeme =
1582: d_es_allocation_memoire;
1583: (*s_etat_processus).instruction_courante =
1584: instruction_courante;
1585: return(d_erreur);
1586: }
1587:
1588: strcpy((*((struct_fonction *) (*(*l_element_fonction)
1589: .donnee).objet)).nom_fonction, ">>");
1590:
1591: (*l_element_fonction).suivant = NULL;
1592:
1593: if (empilement(s_etat_processus, &((*s_etat_processus)
1594: .l_base_pile), s_objet_elementaire) ==
1595: d_erreur)
1596: {
1597: if (presence_egalite == d_vrai)
1598: {
1599: liberation(s_etat_processus, s_objet_evalue);
1600: }
1601:
1602: (*s_etat_processus).instruction_courante =
1603: instruction_courante;
1604: return(d_erreur);
1605: }
1606: }
1607:
1608: (*s_etat_processus).expression_courante =
1609: registre_expression_courante;
1610: }
1611: else
1612: {
1613: if ((s_objet_elementaire =
1614: allocation(s_etat_processus, NON)) == NULL)
1615: {
1616: if (presence_egalite == d_vrai)
1617: {
1618: liberation(s_etat_processus, s_objet_evalue);
1619: }
1620:
1621: (*s_etat_processus).erreur_systeme =
1622: d_es_allocation_memoire;
1623: (*s_etat_processus).instruction_courante =
1624: instruction_courante;
1625: return(d_erreur);
1626: }
1627:
1628: if ((*s_etat_processus).s_liste_variables
1629: [(*s_etat_processus).position_variable_courante]
1630: .objet == NULL)
1631: {
1632: if (pthread_mutex_lock(&((*(*s_etat_processus)
1633: .s_liste_variables_partagees).mutex)) != 0)
1634: {
1635: (*s_etat_processus).erreur_systeme =
1636: d_es_processus;
1637: }
1638:
1639: if (recherche_variable_partagee(s_etat_processus,
1640: ((*s_etat_processus).s_liste_variables
1641: [(*s_etat_processus)
1642: .position_variable_courante]).nom,
1643: ((*s_etat_processus).s_liste_variables
1644: [(*s_etat_processus)
1645: .position_variable_courante])
1646: .variable_partagee, 'E') == d_vrai)
1647: {
1648: // Une variable partagée existe.
1649:
1650: presence_variable_partagee = d_vrai;
1651:
1652: (*s_etat_processus).s_liste_variables
1653: [(*s_etat_processus)
1654: .position_variable_courante].objet =
1655: (*(*s_etat_processus)
1656: .s_liste_variables_partagees).table
1657: [(*(*s_etat_processus)
1658: .s_liste_variables_partagees)
1659: .position_variable].objet;
1660: }
1661: else
1662: {
1663: presence_variable_partagee = d_faux;
1664:
1665: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1666: .s_liste_variables_partagees).mutex)) != 0)
1667: {
1668: (*s_etat_processus).erreur_systeme =
1669: d_es_processus;
1670: }
1671: }
1672: }
1673: else
1674: {
1675: presence_variable_partagee = d_faux;
1676: }
1677:
1678: /*
1679: * Recherche d'un élément dans un vecteur
1680: */
1681:
1682: if (((*s_etat_processus).s_liste_variables
1683: [(*s_etat_processus).position_variable_courante])
1684: .objet == NULL)
1685: {
1686: // La variable partagée n'existe plus.
1687:
1688: free(s_objet_elementaire);
1689:
1690: if ((s_objet_elementaire =
1691: copie_objet(s_etat_processus,
1692: (*l_element_courant).donnee, 'P')) == NULL)
1693: {
1694: if (presence_variable_partagee == d_vrai)
1695: {
1696: (*s_etat_processus).s_liste_variables
1697: [(*s_etat_processus)
1698: .position_variable_courante].objet =
1699: NULL;
1700:
1701: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1702: .s_liste_variables_partagees).mutex))
1703: != 0)
1704: {
1705: (*s_etat_processus).erreur_systeme =
1706: d_es_processus;
1707: }
1708: }
1709:
1710: (*s_etat_processus).erreur_systeme =
1711: d_es_allocation_memoire;
1712: return(d_erreur);;
1713: }
1714: }
1715: else if ((((*(((*s_etat_processus).s_liste_variables
1716: [(*s_etat_processus).position_variable_courante])
1717: .objet)).type == VIN) ||
1718: ((*(((*s_etat_processus).s_liste_variables
1719: [(*s_etat_processus).position_variable_courante])
1720: .objet)).type == VRL) ||
1721: ((*(((*s_etat_processus).s_liste_variables
1722: [(*s_etat_processus).position_variable_courante])
1723: .objet)).type == VCX))
1724: && ((*((struct_fonction *) (*(*l_element_courant)
1725: .donnee).objet)).nombre_arguments == 1))
1726: {
1727: if (depilement(s_etat_processus, &((*s_etat_processus)
1728: .l_base_pile), &s_objet_indice_i) == d_erreur)
1729: {
1730: free(s_objet_elementaire);
1731:
1732: if (presence_variable_partagee == d_vrai)
1733: {
1734: (*s_etat_processus).s_liste_variables
1735: [(*s_etat_processus)
1736: .position_variable_courante].objet =
1737: NULL;
1738:
1739: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1740: .s_liste_variables_partagees).mutex))
1741: != 0)
1742: {
1743: (*s_etat_processus).erreur_systeme =
1744: d_es_processus;
1745: }
1746: }
1747:
1748: if (presence_egalite == d_vrai)
1749: {
1750: liberation(s_etat_processus, s_objet_evalue);
1751: }
1752:
1753: (*s_etat_processus).erreur_execution =
1754: d_ex_manque_argument;
1755: (*s_etat_processus).instruction_courante =
1756: instruction_courante;
1757: (*s_etat_processus).mode_execution_programme =
1758: registre_mode_execution_programme;
1759: return(d_erreur);
1760: }
1761:
1762: if ((*s_objet_indice_i).type == INT)
1763: {
1764: liberation(s_etat_processus, s_objet_indice_i);
1765: free(s_objet_elementaire);
1766:
1767: if (presence_variable_partagee == d_vrai)
1768: {
1769: (*s_etat_processus).s_liste_variables
1770: [(*s_etat_processus)
1771: .position_variable_courante].objet =
1772: NULL;
1773:
1774: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1775: .s_liste_variables_partagees).mutex))
1776: != 0)
1777: {
1778: (*s_etat_processus).erreur_systeme =
1779: d_es_processus;
1780: }
1781: }
1782:
1783: if (presence_egalite == d_vrai)
1784: {
1785: liberation(s_etat_processus, s_objet_evalue);
1786: }
1787:
1788: (*s_etat_processus).erreur_execution =
1789: d_ex_erreur_type_argument;
1790: (*s_etat_processus).instruction_courante =
1791: instruction_courante;
1792: (*s_etat_processus).mode_execution_programme =
1793: registre_mode_execution_programme;
1794: return(d_erreur);
1795: }
1796:
1797: i = (*((integer8 *) (*s_objet_indice_i).objet));
1798:
1799: liberation(s_etat_processus, s_objet_indice_i);
1800:
1801: if ((i < 1) || (i > (integer8) (*((struct_vecteur *)
1802: (*(((*s_etat_processus)
1803: .s_liste_variables[(*s_etat_processus)
1804: .position_variable_courante]).objet)).objet))
1805: .taille))
1806: {
1807: free(s_objet_elementaire);
1808:
1809: if (presence_variable_partagee == d_vrai)
1810: {
1811: (*s_etat_processus).s_liste_variables
1812: [(*s_etat_processus)
1813: .position_variable_courante].objet =
1814: NULL;
1815:
1816: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1817: .s_liste_variables_partagees).mutex))
1818: != 0)
1819: {
1820: (*s_etat_processus).erreur_systeme =
1821: d_es_processus;
1822: }
1823: }
1824:
1825: if (presence_egalite == d_vrai)
1826: {
1827: liberation(s_etat_processus, s_objet_evalue);
1828: }
1829:
1830: (*s_etat_processus).erreur_execution =
1831: d_ex_element_inexistant;
1832: (*s_etat_processus).instruction_courante =
1833: instruction_courante;
1834: (*s_etat_processus).mode_execution_programme =
1835: registre_mode_execution_programme;
1836: return(d_erreur);
1837: }
1838:
1839: if ((*(((*s_etat_processus).s_liste_variables
1840: [(*s_etat_processus)
1841: .position_variable_courante]).objet)).type
1842: == VIN)
1843: {
1844: if (((*s_objet_elementaire).objet = malloc(sizeof(
1845: integer8))) == NULL)
1846: {
1847: if (presence_egalite == d_vrai)
1848: {
1849: liberation(s_etat_processus,
1850: s_objet_evalue);
1851: }
1852:
1853: if (presence_variable_partagee == d_vrai)
1854: {
1855: (*s_etat_processus).s_liste_variables
1856: [(*s_etat_processus)
1857: .position_variable_courante].objet
1858: = NULL;
1859:
1860: if (pthread_mutex_unlock(
1861: &((*(*s_etat_processus)
1862: .s_liste_variables_partagees)
1863: .mutex)) != 0)
1864: {
1865: (*s_etat_processus).erreur_systeme =
1866: d_es_processus;
1867: }
1868: }
1869:
1870: (*s_etat_processus).erreur_systeme =
1871: d_es_allocation_memoire;
1872: (*s_etat_processus).instruction_courante =
1873: instruction_courante;
1874: return(d_erreur);
1875: }
1876:
1877: (*s_objet_elementaire).type = INT;
1878: (*((integer8 *) (*s_objet_elementaire).objet)) =
1879: ((integer8 *) (*((struct_vecteur *)
1880: (*(((*s_etat_processus).s_liste_variables
1881: [(*s_etat_processus)
1882: .position_variable_courante]).objet))
1883: .objet)).tableau)[i - 1];
1884: }
1885: else if ((*(((*s_etat_processus)
1886: .s_liste_variables[(*s_etat_processus)
1887: .position_variable_courante]).objet)).type
1888: == VRL)
1889: {
1890: if (((*s_objet_elementaire).objet = malloc(sizeof(
1891: real8))) == NULL)
1892: {
1893: if (presence_variable_partagee == d_vrai)
1894: {
1895: (*s_etat_processus).s_liste_variables
1896: [(*s_etat_processus)
1897: .position_variable_courante].objet
1898: = NULL;
1899:
1900: if (pthread_mutex_unlock(
1901: &((*(*s_etat_processus)
1902: .s_liste_variables_partagees)
1903: .mutex)) != 0)
1904: {
1905: (*s_etat_processus).erreur_systeme =
1906: d_es_processus;
1907: }
1908: }
1909:
1910: if (presence_egalite == d_vrai)
1911: {
1912: liberation(s_etat_processus,
1913: s_objet_evalue);
1914: }
1915:
1916: (*s_etat_processus).erreur_systeme =
1917: d_es_allocation_memoire;
1918: (*s_etat_processus).instruction_courante =
1919: instruction_courante;
1920: return(d_erreur);
1921: }
1922:
1923: (*s_objet_elementaire).type = REL;
1924: (*((real8 *) (*s_objet_elementaire).objet)) =
1925: ((real8 *) (*((struct_vecteur *)
1926: (*(((*s_etat_processus).s_liste_variables
1927: [(*s_etat_processus)
1928: .position_variable_courante]).objet))
1929: .objet)).tableau)[i - 1];
1930: }
1931: else if ((*(((*s_etat_processus)
1932: .s_liste_variables[(*s_etat_processus)
1933: .position_variable_courante]).objet)).type
1934: == VCX)
1935: {
1936: if (((*s_objet_elementaire).objet = malloc(sizeof(
1937: struct_complexe16))) == NULL)
1938: {
1939: if (presence_variable_partagee == d_vrai)
1940: {
1941: (*s_etat_processus).s_liste_variables
1942: [(*s_etat_processus)
1943: .position_variable_courante].objet
1944: = NULL;
1945:
1946: if (pthread_mutex_unlock(
1947: &((*(*s_etat_processus)
1948: .s_liste_variables_partagees)
1949: .mutex)) != 0)
1950: {
1951: (*s_etat_processus).erreur_systeme =
1952: d_es_processus;
1953: }
1954: }
1955:
1956: if (presence_egalite == d_vrai)
1957: {
1958: liberation(s_etat_processus,
1959: s_objet_evalue);
1960: }
1961:
1962: (*s_etat_processus).erreur_systeme =
1963: d_es_allocation_memoire;
1964: (*s_etat_processus).instruction_courante =
1965: instruction_courante;
1966: return(d_erreur);
1967: }
1968:
1969: (*s_objet_elementaire).type = CPL;
1970: (*((struct_complexe16 *) (*s_objet_elementaire)
1971: .objet)).partie_reelle =
1972: ((struct_complexe16 *) (*((struct_vecteur *)
1973: (*(((*s_etat_processus).s_liste_variables
1974: [(*s_etat_processus)
1975: .position_variable_courante]).objet))
1976: .objet)).tableau)[i - 1]
1977: .partie_reelle;
1978: (*((struct_complexe16 *) (*s_objet_elementaire)
1979: .objet)).partie_imaginaire =
1980: ((struct_complexe16 *) (*((struct_vecteur *)
1981: (*(((*s_etat_processus).s_liste_variables
1982: [(*s_etat_processus)
1983: .position_variable_courante]).objet))
1984: .objet)).tableau)[i - 1]
1985: .partie_imaginaire;
1986: }
1987: }
1988:
1989: /*
1990: * Recherche d'un élément dans une matrice
1991: */
1992:
1993: else if ((((*(((*s_etat_processus).s_liste_variables
1994: [(*s_etat_processus).position_variable_courante])
1995: .objet)).type == MIN) ||
1996: ((*(((*s_etat_processus).s_liste_variables
1997: [(*s_etat_processus).position_variable_courante])
1998: .objet)).type == MRL) ||
1999: ((*(((*s_etat_processus).s_liste_variables
2000: [(*s_etat_processus).position_variable_courante])
2001: .objet)).type == MCX))
2002: && ((*((struct_fonction *) (*(*l_element_courant)
2003: .donnee).objet)).nombre_arguments == 2))
2004: {
2005: if (depilement(s_etat_processus, &((*s_etat_processus)
2006: .l_base_pile), &s_objet_indice_j) == d_erreur)
2007: {
2008: free(s_objet_elementaire);
2009:
2010: if (presence_variable_partagee == d_vrai)
2011: {
2012: (*s_etat_processus).s_liste_variables
2013: [(*s_etat_processus)
2014: .position_variable_courante].objet
2015: = NULL;
2016:
2017: if (pthread_mutex_unlock(
2018: &((*(*s_etat_processus)
2019: .s_liste_variables_partagees)
2020: .mutex)) != 0)
2021: {
2022: (*s_etat_processus).erreur_systeme =
2023: d_es_processus;
2024: }
2025: }
2026:
2027: if (presence_egalite == d_vrai)
2028: {
2029: liberation(s_etat_processus, s_objet_evalue);
2030: }
2031:
2032: (*s_etat_processus).erreur_execution =
2033: d_ex_manque_argument;
2034: (*s_etat_processus).instruction_courante =
2035: instruction_courante;
2036: (*s_etat_processus).mode_execution_programme =
2037: registre_mode_execution_programme;
2038: return(d_erreur);
2039: }
2040:
2041: if (depilement(s_etat_processus, &((*s_etat_processus)
2042: .l_base_pile), &s_objet_indice_i) == d_erreur)
2043: {
2044: liberation(s_etat_processus, s_objet_indice_j);
2045: free(s_objet_elementaire);
2046:
2047: if (presence_variable_partagee == d_vrai)
2048: {
2049: (*s_etat_processus).s_liste_variables
2050: [(*s_etat_processus)
2051: .position_variable_courante].objet
2052: = NULL;
2053:
2054: if (pthread_mutex_unlock(
2055: &((*(*s_etat_processus)
2056: .s_liste_variables_partagees)
2057: .mutex)) != 0)
2058: {
2059: (*s_etat_processus).erreur_systeme =
2060: d_es_processus;
2061: }
2062: }
2063:
2064: if (presence_egalite == d_vrai)
2065: {
2066: liberation(s_etat_processus, s_objet_evalue);
2067: }
2068:
2069: (*s_etat_processus).erreur_execution =
2070: d_ex_manque_argument;
2071: (*s_etat_processus).instruction_courante =
2072: instruction_courante;
2073: (*s_etat_processus).mode_execution_programme =
2074: registre_mode_execution_programme;
2075: return(d_erreur);
2076: }
2077:
2078: if (((*s_objet_indice_i).type != INT) ||
2079: ((*s_objet_indice_j).type != INT))
2080: {
2081: liberation(s_etat_processus, s_objet_indice_i);
2082: liberation(s_etat_processus, s_objet_indice_j);
2083: free(s_objet_elementaire);
2084:
2085: if (presence_variable_partagee == d_vrai)
2086: {
2087: (*s_etat_processus).s_liste_variables
2088: [(*s_etat_processus)
2089: .position_variable_courante].objet
2090: = NULL;
2091:
2092: if (pthread_mutex_unlock(
2093: &((*(*s_etat_processus)
2094: .s_liste_variables_partagees)
2095: .mutex)) != 0)
2096: {
2097: (*s_etat_processus).erreur_systeme =
2098: d_es_processus;
2099: }
2100: }
2101:
2102: if (presence_egalite == d_vrai)
2103: {
2104: liberation(s_etat_processus, s_objet_evalue);
2105: }
2106:
2107: (*s_etat_processus).erreur_execution =
2108: d_ex_erreur_type_argument;
2109: (*s_etat_processus).instruction_courante =
2110: instruction_courante;
2111: (*s_etat_processus).mode_execution_programme =
2112: registre_mode_execution_programme;
2113: return(d_erreur);
2114: }
2115:
2116: i = (*((integer8 *) (*s_objet_indice_i).objet));
2117: j = (*((integer8 *) (*s_objet_indice_j).objet));
2118:
2119: liberation(s_etat_processus, s_objet_indice_i);
2120: liberation(s_etat_processus, s_objet_indice_j);
2121:
2122: if ((i < 1) || (i > (integer8) (*((struct_matrice *)
2123: (*(((*s_etat_processus)
2124: .s_liste_variables[(*s_etat_processus)
2125: .position_variable_courante]).objet)).objet))
2126: .nombre_lignes) || (j < 1) || (j > (integer8)
2127: (*((struct_matrice *) (*(((*s_etat_processus)
2128: .s_liste_variables[(*s_etat_processus)
2129: .position_variable_courante]).objet)).objet))
2130: .nombre_colonnes))
2131: {
2132: liberation(s_etat_processus, s_objet_indice_i);
2133: liberation(s_etat_processus, s_objet_indice_j);
2134: free(s_objet_elementaire);
2135:
2136: if (presence_variable_partagee == d_vrai)
2137: {
2138: (*s_etat_processus).s_liste_variables
2139: [(*s_etat_processus)
2140: .position_variable_courante].objet
2141: = NULL;
2142:
2143: if (pthread_mutex_unlock(
2144: &((*(*s_etat_processus)
2145: .s_liste_variables_partagees)
2146: .mutex)) != 0)
2147: {
2148: (*s_etat_processus).erreur_systeme =
2149: d_es_processus;
2150: }
2151: }
2152:
2153: if (presence_egalite == d_vrai)
2154: {
2155: liberation(s_etat_processus, s_objet_evalue);
2156: }
2157:
2158: (*s_etat_processus).erreur_execution =
2159: d_ex_element_inexistant;
2160: (*s_etat_processus).instruction_courante =
2161: instruction_courante;
2162: (*s_etat_processus).mode_execution_programme =
2163: registre_mode_execution_programme;
2164: return(d_erreur);
2165: }
2166:
2167: if ((*(((*s_etat_processus).s_liste_variables
2168: [(*s_etat_processus)
2169: .position_variable_courante]).objet)).type
2170: == MIN)
2171: {
2172: if (((*s_objet_elementaire).objet = malloc(sizeof(
2173: integer8))) == NULL)
2174: {
2175: if (presence_variable_partagee == d_vrai)
2176: {
2177: (*s_etat_processus).s_liste_variables
2178: [(*s_etat_processus)
2179: .position_variable_courante].objet
2180: = NULL;
2181:
2182: if (pthread_mutex_unlock(
2183: &((*(*s_etat_processus)
2184: .s_liste_variables_partagees)
2185: .mutex)) != 0)
2186: {
2187: (*s_etat_processus).erreur_systeme =
2188: d_es_processus;
2189: }
2190: }
2191:
2192: if (presence_egalite == d_vrai)
2193: {
2194: liberation(s_etat_processus,
2195: s_objet_evalue);
2196: }
2197:
2198: (*s_etat_processus).erreur_systeme =
2199: d_es_allocation_memoire;
2200: (*s_etat_processus).instruction_courante =
2201: instruction_courante;
2202: return(d_erreur);
2203: }
2204:
2205: (*s_objet_elementaire).type = INT;
2206: (*((integer8 *) (*s_objet_elementaire).objet)) =
2207: ((integer8 **) (*((struct_matrice *)
2208: (*(((*s_etat_processus).s_liste_variables
2209: [(*s_etat_processus)
2210: .position_variable_courante]).objet))
2211: .objet)).tableau)[i - 1][j - 1];
2212: }
2213: else if ((*(((*s_etat_processus)
2214: .s_liste_variables[(*s_etat_processus)
2215: .position_variable_courante]).objet)).type
2216: == MRL)
2217: {
2218: if (((*s_objet_elementaire).objet = malloc(sizeof(
2219: real8))) == NULL)
2220: {
2221: if (presence_variable_partagee == d_vrai)
2222: {
2223: (*s_etat_processus).s_liste_variables
2224: [(*s_etat_processus)
2225: .position_variable_courante].objet
2226: = NULL;
2227:
2228: if (pthread_mutex_unlock(
2229: &((*(*s_etat_processus)
2230: .s_liste_variables_partagees)
2231: .mutex)) != 0)
2232: {
2233: (*s_etat_processus).erreur_systeme =
2234: d_es_processus;
2235: }
2236: }
2237:
2238: if (presence_egalite == d_vrai)
2239: {
2240: liberation(s_etat_processus,
2241: s_objet_evalue);
2242: }
2243:
2244: (*s_etat_processus).erreur_systeme =
2245: d_es_allocation_memoire;
2246: (*s_etat_processus).instruction_courante =
2247: instruction_courante;
2248: return(d_erreur);
2249: }
2250:
2251: (*s_objet_elementaire).type = REL;
2252: (*((real8 *) (*s_objet_elementaire).objet)) =
2253: ((real8 **) (*((struct_matrice *)
2254: (*(((*s_etat_processus).s_liste_variables
2255: [(*s_etat_processus)
2256: .position_variable_courante]).objet))
2257: .objet)).tableau)[i - 1][j - 1];
2258: }
2259: else if ((*(((*s_etat_processus)
2260: .s_liste_variables[(*s_etat_processus)
2261: .position_variable_courante]).objet)).type
2262: == MCX)
2263: {
2264: if (((*s_objet_elementaire).objet = malloc(sizeof(
2265: struct_complexe16))) == NULL)
2266: {
2267: if (presence_variable_partagee == d_vrai)
2268: {
2269: (*s_etat_processus).s_liste_variables
2270: [(*s_etat_processus)
2271: .position_variable_courante].objet
2272: = NULL;
2273:
2274: if (pthread_mutex_unlock(
2275: &((*(*s_etat_processus)
2276: .s_liste_variables_partagees)
2277: .mutex)) != 0)
2278: {
2279: (*s_etat_processus).erreur_systeme =
2280: d_es_processus;
2281: }
2282: }
2283:
2284: if (presence_egalite == d_vrai)
2285: {
2286: liberation(s_etat_processus,
2287: s_objet_evalue);
2288: }
2289:
2290: (*s_etat_processus).erreur_systeme =
2291: d_es_allocation_memoire;
2292: (*s_etat_processus).instruction_courante =
2293: instruction_courante;
2294: return(d_erreur);
2295: }
2296:
2297: (*s_objet_elementaire).type = CPL;
2298: (*((struct_complexe16 *) (*s_objet_elementaire)
2299: .objet)).partie_reelle =
2300: ((struct_complexe16 **)
2301: (*((struct_matrice *)
2302: (*(((*s_etat_processus).s_liste_variables
2303: [(*s_etat_processus)
2304: .position_variable_courante]).objet))
2305: .objet)).tableau)[i - 1][j - 1]
2306: .partie_reelle;
2307: (*((struct_complexe16 *) (*s_objet_elementaire)
2308: .objet)).partie_imaginaire =
2309: ((struct_complexe16 **)
2310: (*((struct_matrice *)
2311: (*(((*s_etat_processus).s_liste_variables
2312: [(*s_etat_processus)
2313: .position_variable_courante]).objet))
2314: .objet)).tableau)[i - 1][j - 1]
2315: .partie_imaginaire;
2316: }
2317: }
2318:
2319: /*
2320: * Recherche de l'élément idoine dans la liste
2321: */
2322:
2323: else if (((*(((*s_etat_processus).s_liste_variables
2324: [(*s_etat_processus).position_variable_courante])
2325: .objet)).type == LST) &&
2326: ((*((struct_fonction *) (*(*l_element_courant)
2327: .donnee).objet)).nombre_arguments == 1))
2328: {
2329: if (depilement(s_etat_processus, &((*s_etat_processus)
2330: .l_base_pile), &s_objet_indice_i) == d_erreur)
2331: {
2332: free(s_objet_elementaire);
2333:
2334: if (presence_variable_partagee == d_vrai)
2335: {
2336: (*s_etat_processus).s_liste_variables
2337: [(*s_etat_processus)
2338: .position_variable_courante].objet
2339: = NULL;
2340:
2341: if (pthread_mutex_unlock(
2342: &((*(*s_etat_processus)
2343: .s_liste_variables_partagees)
2344: .mutex)) != 0)
2345: {
2346: (*s_etat_processus).erreur_systeme =
2347: d_es_processus;
2348: }
2349: }
2350:
2351: if (presence_egalite == d_vrai)
2352: {
2353: liberation(s_etat_processus, s_objet_evalue);
2354: }
2355:
2356: (*s_etat_processus).erreur_execution =
2357: d_ex_manque_argument;
2358: (*s_etat_processus).instruction_courante =
2359: instruction_courante;
2360: (*s_etat_processus).mode_execution_programme =
2361: registre_mode_execution_programme;
2362: return(d_erreur);
2363: }
2364:
2365: if ((*s_objet_indice_i).type != INT)
2366: {
2367: liberation(s_etat_processus, s_objet_indice_i);
2368: free(s_objet_elementaire);
2369:
2370: if (presence_variable_partagee == d_vrai)
2371: {
2372: (*s_etat_processus).s_liste_variables
2373: [(*s_etat_processus)
2374: .position_variable_courante].objet
2375: = NULL;
2376:
2377: if (pthread_mutex_unlock(
2378: &((*(*s_etat_processus)
2379: .s_liste_variables_partagees)
2380: .mutex)) != 0)
2381: {
2382: (*s_etat_processus).erreur_systeme =
2383: d_es_processus;
2384: }
2385: }
2386:
2387: if (presence_egalite == d_vrai)
2388: {
2389: liberation(s_etat_processus, s_objet_evalue);
2390: }
2391:
2392: (*s_etat_processus).erreur_execution =
2393: d_ex_erreur_type_argument;
2394: (*s_etat_processus).instruction_courante =
2395: instruction_courante;
2396: (*s_etat_processus).mode_execution_programme =
2397: registre_mode_execution_programme;
2398: return(d_erreur);
2399: }
2400:
2401: i = (*((integer8 *) (*s_objet_indice_i).objet));
2402:
2403: liberation(s_etat_processus, s_objet_indice_i);
2404:
2405: l_sous_element_courant = (*(((*s_etat_processus)
2406: .s_liste_variables[(*s_etat_processus)
2407: .position_variable_courante]).objet)).objet;
2408: j = 0;
2409:
2410: while(l_sous_element_courant != NULL)
2411: {
2412: if ((++j) == i)
2413: {
2414: break;
2415: }
2416:
2417: l_sous_element_courant =
2418: (*l_sous_element_courant).suivant;
2419: }
2420:
2421: if (j != i)
2422: {
2423: free(s_objet_elementaire);
2424:
2425: if (presence_variable_partagee == d_vrai)
2426: {
2427: (*s_etat_processus).s_liste_variables
2428: [(*s_etat_processus)
2429: .position_variable_courante].objet
2430: = NULL;
2431:
2432: if (pthread_mutex_unlock(
2433: &((*(*s_etat_processus)
2434: .s_liste_variables_partagees)
2435: .mutex)) != 0)
2436: {
2437: (*s_etat_processus).erreur_systeme =
2438: d_es_processus;
2439: }
2440: }
2441:
2442: if (presence_egalite == d_vrai)
2443: {
2444: liberation(s_etat_processus, s_objet_evalue);
2445: }
2446:
2447: (*s_etat_processus).erreur_execution =
2448: d_ex_element_inexistant;
2449: (*s_etat_processus).instruction_courante =
2450: instruction_courante;
2451: (*s_etat_processus).mode_execution_programme =
2452: registre_mode_execution_programme;
2453: return(d_erreur);
2454: }
2455:
2456: free(s_objet_elementaire);
2457:
2458: if ((s_objet_elementaire =
2459: copie_objet(s_etat_processus,
2460: (*l_sous_element_courant).donnee, 'P')) == NULL)
2461: {
2462: if (presence_variable_partagee == d_vrai)
2463: {
2464: (*s_etat_processus).s_liste_variables
2465: [(*s_etat_processus)
2466: .position_variable_courante].objet
2467: = NULL;
2468:
2469: if (pthread_mutex_unlock(
2470: &((*(*s_etat_processus)
2471: .s_liste_variables_partagees)
2472: .mutex)) != 0)
2473: {
2474: (*s_etat_processus).erreur_systeme =
2475: d_es_processus;
2476: }
2477: }
2478:
2479: if (presence_egalite == d_vrai)
2480: {
2481: liberation(s_etat_processus, s_objet_evalue);
2482: }
2483:
2484: (*s_etat_processus).erreur_systeme =
2485: d_es_allocation_memoire;
2486: (*s_etat_processus).instruction_courante =
2487: instruction_courante;
2488: return(d_erreur);
2489: }
2490: }
2491:
2492: /*
2493: * Recherche de l'élément idoine dans la table
2494: */
2495:
2496: else if (((*(((*s_etat_processus).s_liste_variables
2497: [(*s_etat_processus).position_variable_courante])
2498: .objet)).type == TAB) &&
2499: ((*((struct_fonction *) (*(*l_element_courant)
2500: .donnee).objet)).nombre_arguments == 1))
2501: {
2502: if (depilement(s_etat_processus, &((*s_etat_processus)
2503: .l_base_pile), &s_objet_indice_i) == d_erreur)
2504: {
2505: free(s_objet_elementaire);
2506:
2507: if (presence_variable_partagee == d_vrai)
2508: {
2509: (*s_etat_processus).s_liste_variables
2510: [(*s_etat_processus)
2511: .position_variable_courante].objet
2512: = NULL;
2513:
2514: if (pthread_mutex_unlock(
2515: &((*(*s_etat_processus)
2516: .s_liste_variables_partagees)
2517: .mutex)) != 0)
2518: {
2519: (*s_etat_processus).erreur_systeme =
2520: d_es_processus;
2521: }
2522: }
2523:
2524: if (presence_egalite == d_vrai)
2525: {
2526: liberation(s_etat_processus, s_objet_evalue);
2527: }
2528:
2529: (*s_etat_processus).erreur_execution =
2530: d_ex_manque_argument;
2531: (*s_etat_processus).instruction_courante =
2532: instruction_courante;
2533: (*s_etat_processus).mode_execution_programme =
2534: registre_mode_execution_programme;
2535: return(d_erreur);
2536: }
2537:
2538: if ((*s_objet_indice_i).type != INT)
2539: {
2540: liberation(s_etat_processus, s_objet_indice_i);
2541: free(s_objet_elementaire);
2542:
2543: if (presence_variable_partagee == d_vrai)
2544: {
2545: (*s_etat_processus).s_liste_variables
2546: [(*s_etat_processus)
2547: .position_variable_courante].objet
2548: = NULL;
2549:
2550: if (pthread_mutex_unlock(
2551: &((*(*s_etat_processus)
2552: .s_liste_variables_partagees)
2553: .mutex)) != 0)
2554: {
2555: (*s_etat_processus).erreur_systeme =
2556: d_es_processus;
2557: }
2558: }
2559:
2560: if (presence_egalite == d_vrai)
2561: {
2562: liberation(s_etat_processus, s_objet_evalue);
2563: }
2564:
2565: (*s_etat_processus).erreur_execution =
2566: d_ex_erreur_type_argument;
2567: (*s_etat_processus).instruction_courante =
2568: instruction_courante;
2569: (*s_etat_processus).mode_execution_programme =
2570: registre_mode_execution_programme;
2571: return(d_erreur);
2572: }
2573:
2574: i = (*((integer8 *) (*s_objet_indice_i).objet));
2575:
2576: liberation(s_etat_processus, s_objet_indice_i);
2577:
2578: if ((i < 1) || (i > (integer8) (*((struct_tableau *)
2579: (*((*s_etat_processus).s_liste_variables
2580: [(*s_etat_processus)
2581: .position_variable_courante]).objet)
2582: .objet)).nombre_elements))
2583: {
2584: free(s_objet_elementaire);
2585:
2586: if (presence_variable_partagee == d_vrai)
2587: {
2588: (*s_etat_processus).s_liste_variables
2589: [(*s_etat_processus)
2590: .position_variable_courante].objet
2591: = NULL;
2592:
2593: if (pthread_mutex_unlock(
2594: &((*(*s_etat_processus)
2595: .s_liste_variables_partagees)
2596: .mutex)) != 0)
2597: {
2598: (*s_etat_processus).erreur_systeme =
2599: d_es_processus;
2600: }
2601: }
2602:
2603: if (presence_egalite == d_vrai)
2604: {
2605: liberation(s_etat_processus, s_objet_evalue);
2606: }
2607:
2608: (*s_etat_processus).erreur_execution =
2609: d_ex_element_inexistant;
2610: (*s_etat_processus).instruction_courante =
2611: instruction_courante;
2612: (*s_etat_processus).mode_execution_programme =
2613: registre_mode_execution_programme;
2614: return(d_erreur);
2615: }
2616:
2617: free(s_objet_elementaire);
2618:
2619: if ((s_objet_elementaire =
2620: copie_objet(s_etat_processus,
2621: (*((struct_tableau *) (*((*s_etat_processus)
2622: .s_liste_variables[(*s_etat_processus)
2623: .position_variable_courante]).objet)
2624: .objet)).elements[i - 1], 'P')) == NULL)
2625: {
2626: if (presence_variable_partagee == d_vrai)
2627: {
2628: (*s_etat_processus).s_liste_variables
2629: [(*s_etat_processus)
2630: .position_variable_courante].objet
2631: = NULL;
2632:
2633: if (pthread_mutex_unlock(
2634: &((*(*s_etat_processus)
2635: .s_liste_variables_partagees)
2636: .mutex)) != 0)
2637: {
2638: (*s_etat_processus).erreur_systeme =
2639: d_es_processus;
2640: }
2641: }
2642:
2643: if (presence_egalite == d_vrai)
2644: {
2645: liberation(s_etat_processus, s_objet_evalue);
2646: }
2647:
2648: (*s_etat_processus).erreur_systeme =
2649: d_es_allocation_memoire;
2650: (*s_etat_processus).instruction_courante =
2651: instruction_courante;
2652: return(d_erreur);
2653: }
2654: }
2655: else if (((*(((*s_etat_processus).s_liste_variables
2656: [(*s_etat_processus).position_variable_courante])
2657: .objet)).type == ALG) ||
2658: ((*(((*s_etat_processus).s_liste_variables
2659: [(*s_etat_processus).position_variable_courante])
2660: .objet)).type == RPN))
2661: {
2662: registre_evaluation_expression_compilee =
2663: (*s_etat_processus)
2664: .evaluation_expression_compilee;
2665:
2666: if (((*s_etat_processus).s_liste_variables
2667: [(*s_etat_processus)
2668: .position_variable_courante].origine == 'E') &&
2669: ((*s_etat_processus).s_liste_variables
2670: [(*s_etat_processus).position_variable_courante]
2671: .niveau == 0))
2672: {
2673: (*s_etat_processus).evaluation_expression_compilee =
2674: 'Y';
2675: }
2676: else
2677: {
2678: (*s_etat_processus).evaluation_expression_compilee =
2679: 'N';
2680: }
2681:
2682: if (evaluation(s_etat_processus, (*s_etat_processus)
2683: .s_liste_variables[(*s_etat_processus)
2684: .position_variable_courante].objet,
2685: type_evaluation) == d_erreur)
2686: {
2687: (*s_etat_processus).evaluation_expression_compilee =
2688: registre_evaluation_expression_compilee;
2689:
2690: if (presence_variable_partagee == d_vrai)
2691: {
2692: (*s_etat_processus).s_liste_variables
2693: [(*s_etat_processus)
2694: .position_variable_courante].objet
2695: = NULL;
2696:
2697: if (pthread_mutex_unlock(
2698: &((*(*s_etat_processus)
2699: .s_liste_variables_partagees)
2700: .mutex)) != 0)
2701: {
2702: (*s_etat_processus).erreur_systeme =
2703: d_es_processus;
2704: }
2705: }
2706:
2707: if (presence_egalite == d_vrai)
2708: {
2709: liberation(s_etat_processus, s_objet_evalue);
2710: }
2711:
2712: (*s_etat_processus).instruction_courante =
2713: instruction_courante;
2714: (*s_etat_processus).mode_execution_programme =
2715: registre_mode_execution_programme;
2716: return(d_erreur);
2717: }
2718:
2719: (*s_etat_processus).evaluation_expression_compilee =
2720: registre_evaluation_expression_compilee;
2721:
2722: free(s_objet_elementaire);
2723:
2724: if (depilement(s_etat_processus, &((*s_etat_processus)
2725: .l_base_pile), &s_objet_elementaire)
2726: == d_erreur)
2727: {
2728: if (presence_variable_partagee == d_vrai)
2729: {
2730: (*s_etat_processus).s_liste_variables
2731: [(*s_etat_processus)
2732: .position_variable_courante].objet
2733: = NULL;
2734:
2735: if (pthread_mutex_unlock(
2736: &((*(*s_etat_processus)
2737: .s_liste_variables_partagees)
2738: .mutex)) != 0)
2739: {
2740: (*s_etat_processus).erreur_systeme =
2741: d_es_processus;
2742: }
2743: }
2744:
2745: if (presence_egalite == d_vrai)
2746: {
2747: liberation(s_etat_processus, s_objet_evalue);
2748: }
2749:
2750: (*s_etat_processus).erreur_execution =
2751: d_ex_manque_argument;
2752: (*s_etat_processus).instruction_courante =
2753: instruction_courante;
2754: (*s_etat_processus).mode_execution_programme =
2755: registre_mode_execution_programme;
2756: return(d_erreur);
2757: }
2758: }
2759: else if ((*(((*s_etat_processus).s_liste_variables
2760: [(*s_etat_processus).position_variable_courante])
2761: .objet)).type == ADR)
2762: {
2763: autorisation_empilement_programme = (*s_etat_processus)
2764: .autorisation_empilement_programme;
2765: registre_position_courante = (*s_etat_processus)
2766: .position_courante;
2767:
2768: empilement_pile_systeme(s_etat_processus);
2769:
2770: if ((*s_etat_processus).erreur_systeme != d_es)
2771: {
2772: if (presence_variable_partagee == d_vrai)
2773: {
2774: (*s_etat_processus).s_liste_variables
2775: [(*s_etat_processus)
2776: .position_variable_courante].objet
2777: = NULL;
2778:
2779: if (pthread_mutex_unlock(
2780: &((*(*s_etat_processus)
2781: .s_liste_variables_partagees)
2782: .mutex)) != 0)
2783: {
2784: (*s_etat_processus).erreur_systeme =
2785: d_es_processus;
2786: }
2787: }
2788:
2789: if (presence_egalite == d_vrai)
2790: {
2791: liberation(s_etat_processus, s_objet_evalue);
2792: }
2793:
2794: (*s_etat_processus).instruction_courante =
2795: instruction_courante;
2796: return(d_erreur);
2797: }
2798:
2799: (*(*s_etat_processus).l_base_pile_systeme)
2800: .retour_definition = 'Y';
2801: (*(*s_etat_processus).l_base_pile_systeme)
2802: .origine_routine_evaluation = 'Y';
2803:
2804: (*s_etat_processus).mode_execution_programme = 'Y';
2805: (*s_etat_processus).autorisation_empilement_programme
2806: = 'N';
2807:
2808: (*(*s_etat_processus).l_base_pile_systeme)
2809: .niveau_courant = (*s_etat_processus)
2810: .niveau_courant;
2811:
2812: (*s_etat_processus).position_courante =
2813: (*((unsigned long *)
2814: ((*((*s_etat_processus).s_liste_variables
2815: [(*s_etat_processus)
2816: .position_variable_courante]
2817: .objet)).objet)));
2818:
2819: if ((*s_etat_processus).profilage == d_vrai)
2820: {
2821: profilage(s_etat_processus,
2822: (*s_etat_processus).s_liste_variables
2823: [(*s_etat_processus)
2824: .position_variable_courante].nom);
2825:
2826: if ((*s_etat_processus).erreur_systeme != d_es)
2827: {
2828: if (presence_variable_partagee == d_vrai)
2829: {
2830: (*s_etat_processus).s_liste_variables
2831: [(*s_etat_processus)
2832: .position_variable_courante].objet
2833: = NULL;
2834:
2835: if (pthread_mutex_unlock(
2836: &((*(*s_etat_processus)
2837: .s_liste_variables_partagees)
2838: .mutex)) != 0)
2839: {
2840: (*s_etat_processus).erreur_systeme =
2841: d_es_processus;
2842: }
2843: }
2844:
2845: return(d_erreur);
2846: }
2847: }
2848:
2849: if (sequenceur(s_etat_processus) == d_erreur)
2850: {
2851: if (presence_variable_partagee == d_vrai)
2852: {
2853: (*s_etat_processus).s_liste_variables
2854: [(*s_etat_processus)
2855: .position_variable_courante].objet
2856: = NULL;
2857:
2858: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2859: .s_liste_variables_partagees)
2860: .mutex)) != 0)
2861: {
2862: (*s_etat_processus).erreur_systeme =
2863: d_es_processus;
2864: }
2865: }
2866:
2867: if (presence_egalite == d_vrai)
2868: {
2869: liberation(s_etat_processus, s_objet_evalue);
2870: }
2871:
2872: (*s_etat_processus).instruction_courante =
2873: instruction_courante;
2874: (*s_etat_processus).mode_execution_programme =
2875: registre_mode_execution_programme;
2876: return(d_erreur);
2877: }
2878:
2879: (*s_etat_processus).instruction_courante =
2880: instruction_courante;
2881: (*s_etat_processus).mode_execution_programme = 'N';
2882:
2883: depilement_pile_systeme(s_etat_processus);
2884:
2885: if ((*s_etat_processus).erreur_systeme != d_es)
2886: {
2887: if (presence_variable_partagee == d_vrai)
2888: {
2889: (*s_etat_processus).s_liste_variables
2890: [(*s_etat_processus)
2891: .position_variable_courante].objet
2892: = NULL;
2893:
2894: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2895: .s_liste_variables_partagees)
2896: .mutex)) != 0)
2897: {
2898: (*s_etat_processus).erreur_systeme =
2899: d_es_processus;
2900: }
2901: }
2902:
2903: if (presence_egalite == d_vrai)
2904: {
2905: liberation(s_etat_processus, s_objet_evalue);
2906: }
2907:
2908: return(d_erreur);
2909: }
2910:
2911: (*s_etat_processus).retour_routine_evaluation = 'N';
2912: (*s_etat_processus).position_courante =
2913: registre_position_courante;
2914: (*s_etat_processus).autorisation_empilement_programme =
2915: autorisation_empilement_programme;
2916:
2917: free(s_objet_elementaire);
2918:
2919: if (depilement(s_etat_processus, &((*s_etat_processus)
2920: .l_base_pile), &s_objet_elementaire)
2921: == d_erreur)
2922: {
2923: if (presence_variable_partagee == d_vrai)
2924: {
2925: (*s_etat_processus).s_liste_variables
2926: [(*s_etat_processus)
2927: .position_variable_courante].objet
2928: = NULL;
2929:
2930: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2931: .s_liste_variables_partagees).mutex))
2932: != 0)
2933: {
2934: (*s_etat_processus).erreur_systeme =
2935: d_es_processus;
2936: }
2937: }
2938:
2939: if (presence_egalite == d_vrai)
2940: {
2941: liberation(s_etat_processus, s_objet_evalue);
2942: }
2943:
2944: (*s_etat_processus).erreur_execution =
2945: d_ex_manque_argument;
2946: (*s_etat_processus).instruction_courante =
2947: instruction_courante;
2948: (*s_etat_processus).mode_execution_programme =
2949: registre_mode_execution_programme;
2950: return(d_erreur);
2951: }
2952: }
2953: else
2954: {
2955: if (presence_variable_partagee == d_vrai)
2956: {
2957: (*s_etat_processus).s_liste_variables
2958: [(*s_etat_processus)
2959: .position_variable_courante].objet
2960: = NULL;
2961:
2962: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2963: .s_liste_variables_partagees) .mutex)) != 0)
2964: {
2965: (*s_etat_processus).erreur_systeme =
2966: d_es_processus;
2967: }
2968: }
2969:
2970: if (presence_egalite == d_vrai)
2971: {
2972: liberation(s_etat_processus, s_objet_evalue);
2973: }
2974:
2975: (*s_etat_processus).erreur_execution =
2976: d_ex_element_inexistant;
2977: (*s_etat_processus).instruction_courante =
2978: instruction_courante;
2979: (*s_etat_processus).mode_execution_programme =
2980: registre_mode_execution_programme;
2981:
2982: return(d_erreur);
2983: }
2984:
2985: if (empilement(s_etat_processus, &((*s_etat_processus)
2986: .l_base_pile), s_objet_elementaire) == d_erreur)
2987: {
2988: if (presence_variable_partagee == d_vrai)
2989: {
2990: (*s_etat_processus).s_liste_variables
2991: [(*s_etat_processus)
2992: .position_variable_courante].objet
2993: = NULL;
2994:
2995: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2996: .s_liste_variables_partagees).mutex)) != 0)
2997: {
2998: (*s_etat_processus).erreur_systeme =
2999: d_es_processus;
3000: }
3001: }
3002:
3003: if (presence_egalite == d_vrai)
3004: {
3005: liberation(s_etat_processus, s_objet_evalue);
3006: }
3007:
3008: (*s_etat_processus).instruction_courante =
3009: instruction_courante;
3010: return(d_erreur);
3011: }
3012:
3013: if (presence_variable_partagee == d_vrai)
3014: {
3015: (*s_etat_processus).s_liste_variables
3016: [(*s_etat_processus)
3017: .position_variable_courante].objet
3018: = NULL;
3019:
3020: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3021: .s_liste_variables_partagees).mutex)) != 0)
3022: {
3023: (*s_etat_processus).erreur_systeme =
3024: d_es_processus;
3025: }
3026: }
3027: }
3028: }
3029: else if (((*(*l_element_courant).donnee).type == ALG)
3030: || ((*(*l_element_courant).donnee).type == RPN))
3031: {
3032: if (type_evaluation == 'I')
3033: {
3034: if ((s_objet_elementaire = copie_objet(s_etat_processus,
3035: (*l_element_courant).donnee, 'P')) == NULL)
3036: {
3037: if (presence_egalite == d_vrai)
3038: {
3039: liberation(s_etat_processus, s_objet_evalue);
3040: }
3041:
3042: (*s_etat_processus).erreur_systeme =
3043: d_es_allocation_memoire;
3044: (*s_etat_processus).instruction_courante =
3045: instruction_courante;
3046: return(d_erreur);
3047: }
3048:
3049: if (empilement(s_etat_processus, &((*s_etat_processus)
3050: .l_base_pile), s_objet_elementaire)
3051: == d_erreur)
3052: {
3053: if (presence_egalite == d_vrai)
3054: {
3055: liberation(s_etat_processus, s_objet_evalue);
3056: }
3057:
3058: (*s_etat_processus).instruction_courante =
3059: instruction_courante;
3060: return(d_erreur);
3061: }
3062: }
3063: else
3064: {
3065: if ((*s_etat_processus).autorisation_empilement_programme
3066: == 'N')
3067: {
3068: registre_evaluation_expression_compilee =
3069: (*s_etat_processus)
3070: .evaluation_expression_compilee;
3071:
3072: (*s_etat_processus).evaluation_expression_compilee
3073: = 'N';
3074:
3075: if (evaluation(s_etat_processus, (*l_element_courant)
3076: .donnee, type_evaluation) == d_erreur)
3077: {
3078: (*s_etat_processus).evaluation_expression_compilee
3079: = registre_evaluation_expression_compilee;
3080:
3081: if (presence_egalite == d_vrai)
3082: {
3083: liberation(s_etat_processus, s_objet_evalue);
3084: }
3085:
3086: (*s_etat_processus).instruction_courante =
3087: instruction_courante;
3088: (*s_etat_processus).mode_execution_programme =
3089: registre_mode_execution_programme;
3090: return(d_erreur);
3091: }
3092:
3093: (*s_etat_processus).evaluation_expression_compilee
3094: = registre_evaluation_expression_compilee;
3095: }
3096: else
3097: {
3098: if ((s_objet_elementaire =
3099: copie_objet(s_etat_processus,
3100: (*l_element_courant).donnee, 'P')) == NULL)
3101: {
3102: if (presence_egalite == d_vrai)
3103: {
3104: liberation(s_etat_processus, s_objet_evalue);
3105: }
3106:
3107: (*s_etat_processus).erreur_systeme =
3108: d_es_allocation_memoire;
3109: (*s_etat_processus).instruction_courante =
3110: instruction_courante;
3111: return(d_erreur);
3112: }
3113:
3114: if (empilement(s_etat_processus, &((*s_etat_processus)
3115: .l_base_pile), s_objet_elementaire)
3116: == d_erreur)
3117: {
3118: if (presence_egalite == d_vrai)
3119: {
3120: liberation(s_etat_processus, s_objet_evalue);
3121: }
3122:
3123: (*s_etat_processus).instruction_courante =
3124: instruction_courante;
3125: return(d_erreur);
3126: }
3127: }
3128: }
3129: }
3130: else if ((*(*l_element_courant).donnee).type == NOM)
3131: {
3132: registre_instruction_valide = (*s_etat_processus)
3133: .instruction_valide;
3134: registre_test = (*s_etat_processus).test_instruction;
3135: (*s_etat_processus).test_instruction = 'Y';
3136: (*s_etat_processus).instruction_courante = (*((struct_nom *)
3137: (*(*l_element_courant).donnee).objet)).nom;
3138:
3139: analyse(s_etat_processus, NULL);
3140:
3141: (*s_etat_processus).test_instruction = 'N';
3142:
3143: if ((*s_etat_processus).instruction_valide == 'Y')
3144: {
3145: registre_test_2 = (*s_etat_processus).test_instruction;
3146: (*s_etat_processus).test_instruction = 'N';
3147:
3148: analyse(s_etat_processus, NULL);
3149:
3150: (*s_etat_processus).test_instruction = registre_test_2;
3151:
3152: if ((*s_etat_processus).erreur_systeme != d_es)
3153: {
3154: if (presence_egalite == d_vrai)
3155: {
3156: liberation(s_etat_processus, s_objet_evalue);
3157: }
3158:
3159: if ((*s_etat_processus).var_volatile_processus_pere
3160: == 0)
3161: {
3162: kill((*s_etat_processus)
3163: .pid_processus_pere, SIGALRM);
3164: }
3165: else
3166: {
3167: (*s_etat_processus).var_volatile_alarme = -1;
3168: }
3169:
3170: (*s_etat_processus).instruction_courante =
3171: instruction_courante;
3172: return(d_erreur);
3173: }
3174: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3175: ((*s_etat_processus).exception != d_ep))
3176: {
3177: if ((*s_etat_processus).arret_si_exception == d_faux)
3178: {
3179: /*
3180: * Reprise sur erreur
3181: */
3182:
3183: if ((message = messages(s_etat_processus)) == NULL)
3184: {
3185: if (presence_egalite == d_vrai)
3186: {
3187: liberation(s_etat_processus,
3188: s_objet_evalue);
3189: }
3190:
3191: (*s_etat_processus).instruction_courante =
3192: instruction_courante;
3193: return(d_erreur);
3194: }
3195:
3196: free(message);
3197:
3198: while((*(*s_etat_processus).l_base_pile_systeme)
3199: .clause != 'R')
3200: {
3201: l_registre_atome = l_element_courant;
3202: l_element_courant =
3203: (*l_element_courant).suivant;
3204:
3205: if (l_element_courant == NULL)
3206: {
3207: /*
3208: * La fin de l'expression est atteinte,
3209: * le sequenceur reprend la main.
3210: */
3211:
3212: if (presence_egalite == d_vrai)
3213: {
3214: liberation(s_etat_processus,
3215: s_objet_evalue);
3216: }
3217:
3218: (*s_etat_processus)
3219: .mode_execution_programme =
3220: registre_mode_execution_programme;
3221: return(d_absence_erreur);
3222: }
3223:
3224: if ((*(*l_element_courant).donnee).type == FCT)
3225: {
3226: (*s_etat_processus).instruction_courante =
3227: (*((struct_fonction *)
3228: (*(*l_element_courant).donnee)
3229: .objet)).nom_fonction;
3230:
3231: if (recherche_variable(s_etat_processus,
3232: (*s_etat_processus)
3233: .instruction_courante) == d_faux)
3234: {
3235: (*s_etat_processus).erreur_systeme
3236: = d_es;
3237: fonction = (*((struct_fonction *)
3238: (*(*l_element_courant).donnee)
3239: .objet)).fonction;
3240:
3241: /*
3242: * Traitement de la pile système par les
3243: * différentes instructions.
3244: */
3245:
3246: if (TEST(instruction_if) ||
3247: TEST(instruction_iferr) ||
3248: TEST(instruction_do) ||
3249: TEST(instruction_while) ||
3250: TEST(instruction_for) ||
3251: TEST(instruction_start) ||
3252: TEST(instruction_select) ||
3253: TEST(instruction_case) ||
3254: TEST(vers_niveau_superieur))
3255: {
3256: if (TEST(vers_niveau_superieur))
3257: {
3258: registre_exception =
3259: (*s_etat_processus)
3260: .exception;
3261: registre_erreur_execution =
3262: (*s_etat_processus)
3263: .erreur_execution;
3264:
3265: analyse(s_etat_processus,
3266: vers_niveau_superieur);
3267:
3268: if ((*s_etat_processus)
3269: .erreur_systeme != d_es)
3270: {
3271: (*s_etat_processus)
3272: .instruction_courante =
3273: instruction_courante;
3274: return(d_erreur);
3275: }
3276:
3277: (*s_etat_processus).exception
3278: = registre_exception;
3279: (*s_etat_processus)
3280: .erreur_execution =
3281: registre_erreur_execution;
3282: }
3283: else
3284: {
3285: empilement_pile_systeme(
3286: s_etat_processus);
3287:
3288: if ((*s_etat_processus)
3289: .erreur_systeme != d_es)
3290: {
3291: if (presence_egalite ==
3292: d_vrai)
3293: {
3294: liberation(
3295: s_etat_processus,
3296: s_objet_evalue);
3297: }
3298:
3299: (*s_etat_processus)
3300: .instruction_courante =
3301: instruction_courante;
3302: return(d_erreur);
3303: }
3304: }
3305: }
3306: else if (TEST(instruction_end) ||
3307: TEST(instruction_next) ||
3308: TEST(instruction_step) ||
3309: TEST(vers_niveau_inferieur))
3310: {
3311: if (TEST(vers_niveau_inferieur))
3312: {
3313: registre_exception =
3314: (*s_etat_processus)
3315: .exception;
3316: registre_erreur_execution =
3317: (*s_etat_processus)
3318: .erreur_execution;
3319:
3320: analyse(s_etat_processus,
3321: vers_niveau_inferieur);
3322:
3323: if ((*s_etat_processus)
3324: .erreur_systeme != d_es)
3325: {
3326: (*s_etat_processus)
3327: .instruction_courante =
3328: instruction_courante;
3329: return(d_erreur);
3330: }
3331:
3332: (*s_etat_processus).exception
3333: = registre_exception;
3334: (*s_etat_processus)
3335: .erreur_execution =
3336: registre_erreur_execution;
3337: }
3338: else
3339: {
3340: depilement_pile_systeme(
3341: s_etat_processus);
3342:
3343: if ((*s_etat_processus)
3344: .erreur_systeme != d_es)
3345: {
3346: if (presence_egalite ==
3347: d_vrai)
3348: {
3349: liberation(
3350: s_etat_processus,
3351: s_objet_evalue);
3352: }
3353:
3354: (*s_etat_processus)
3355: .instruction_courante =
3356: instruction_courante;
3357: return(d_erreur);
3358: }
3359: }
3360: }
3361: }
3362: }
3363: }
3364:
3365: (*s_etat_processus).instruction_courante =
3366: instruction_courante;
3367: drapeau_then = d_faux;
3368:
3369: do
3370: {
3371: l_registre_atome = l_element_courant;
3372:
3373: if (l_element_courant == NULL)
3374: {
3375: /*
3376: * La fin de l'expression est atteinte,
3377: * le sequenceur reprend la main.
3378: */
3379:
3380: if (presence_egalite == d_vrai)
3381: {
3382: liberation(s_etat_processus,
3383: s_objet_evalue);
3384: }
3385:
3386: (*s_etat_processus)
3387: .mode_execution_programme =
3388: registre_mode_execution_programme;
3389: (*s_etat_processus).instruction_courante =
3390: instruction_courante;
3391: return(d_absence_erreur);
3392: }
3393:
3394: if ((*(*l_element_courant).donnee).type == FCT)
3395: {
3396: (*s_etat_processus)
3397: .instruction_courante =
3398: (*((struct_fonction *)
3399: (*(*l_element_courant).donnee)
3400: .objet)).nom_fonction;
3401: fonction = (*((struct_fonction *)
3402: (*(*l_element_courant).donnee)
3403: .objet)).fonction;
3404: (*s_etat_processus).instruction_courante =
3405: instruction_courante;
3406:
3407: drapeau_then = TEST(instruction_then)
3408: ? d_vrai : d_faux;
3409: }
3410:
3411: l_element_courant = (*l_element_courant)
3412: .suivant;
3413: } while(drapeau_then == d_faux);
3414:
3415: (*s_etat_processus).expression_courante =
3416: l_registre_atome;
3417:
3418: (*(*s_etat_processus).l_base_pile_systeme)
3419: .clause = 'X';
3420: instruction_then(s_etat_processus);
3421:
3422: (*s_etat_processus).exception = d_ep;
3423: (*s_etat_processus).erreur_execution = d_ex;
3424: }
3425: else if ((*s_etat_processus).mode_evaluation_expression
3426: == 'Y')
3427: {
3428: /*
3429: * Reprise sur erreur
3430: */
3431:
3432: while(l_element_courant != NULL)
3433: {
3434: if ((*(*l_element_courant).donnee).type == FCT)
3435: {
3436: (*s_etat_processus).instruction_courante =
3437: (*((struct_fonction *)
3438: (*(*l_element_courant).donnee)
3439: .objet)).nom_fonction;
3440: fonction = (*((struct_fonction *)
3441: (*(*l_element_courant).donnee)
3442: .objet)).fonction;
3443:
3444: if (recherche_variable(s_etat_processus,
3445: (*s_etat_processus)
3446: .instruction_courante) == d_faux)
3447: {
3448: (*s_etat_processus).erreur_systeme
3449: = d_es;
3450:
3451: /*
3452: * Traitement de la pile système par les
3453: * différentes instructions.
3454: */
3455:
3456: if (TEST(instruction_if) ||
3457: TEST(instruction_iferr) ||
3458: TEST(instruction_do) ||
3459: TEST(instruction_while) ||
3460: TEST(instruction_for) ||
3461: TEST(instruction_start) ||
3462: TEST(instruction_select) ||
3463: TEST(instruction_case) ||
3464: TEST(vers_niveau_superieur))
3465: {
3466: if (TEST(vers_niveau_superieur))
3467: {
3468: analyse(s_etat_processus,
3469: vers_niveau_superieur);
3470:
3471: if ((*s_etat_processus)
3472: .erreur_systeme != d_es)
3473: {
3474: (*s_etat_processus)
3475: .instruction_courante =
3476: instruction_courante;
3477: return(d_erreur);
3478: }
3479: }
3480: else
3481: {
3482: empilement_pile_systeme(
3483: s_etat_processus);
3484:
3485: if ((*s_etat_processus)
3486: .erreur_systeme != d_es)
3487: {
3488: if (presence_egalite ==
3489: d_vrai)
3490: {
3491: liberation(
3492: s_etat_processus,
3493: s_objet_evalue);
3494: }
3495:
3496: (*s_etat_processus)
3497: .instruction_courante =
3498: instruction_courante;
3499: return(d_erreur);
3500: }
3501: }
3502: }
3503: else if (TEST(instruction_end) ||
3504: TEST(instruction_next) ||
3505: TEST(instruction_step) ||
3506: TEST(vers_niveau_inferieur))
3507: {
3508: if (TEST(vers_niveau_inferieur))
3509: {
3510: analyse(s_etat_processus,
3511: vers_niveau_inferieur);
3512:
3513: if ((*s_etat_processus)
3514: .erreur_systeme != d_es)
3515: {
3516: (*s_etat_processus)
3517: .instruction_courante =
3518: instruction_courante;
3519: return(d_erreur);
3520: }
3521: }
3522: else
3523: {
3524: depilement_pile_systeme(
3525: s_etat_processus);
3526:
3527: if ((*s_etat_processus)
3528: .erreur_systeme != d_es)
3529: {
3530: if (presence_egalite ==
3531: d_vrai)
3532: {
3533: liberation(
3534: s_etat_processus,
3535: s_objet_evalue);
3536: }
3537:
3538: (*s_etat_processus)
3539: .instruction_courante =
3540: instruction_courante;
3541: return(d_erreur);
3542: }
3543: }
3544: }
3545: }
3546: }
3547:
3548: l_element_courant =
3549: (*l_element_courant).suivant;
3550: }
3551:
3552: (*s_etat_processus).mode_execution_programme =
3553: registre_mode_execution_programme;
3554: (*s_etat_processus).instruction_courante =
3555: instruction_courante;
3556:
3557: (*s_etat_processus).exception = d_ep;
3558: (*s_etat_processus).erreur_execution = d_ex;
3559:
3560: erreur_evaluation = d_erreur;
3561: }
3562: else
3563: {
3564: // On ne détruit pas les variables pour les inclure
3565: // dans le fichier rpl-core.
3566:
3567: (*s_etat_processus).gel_liste_variables = d_vrai;
3568:
3569: registre_erreur_execution =
3570: (*s_etat_processus).erreur_execution;
3571: registre_exception =
3572: (*s_etat_processus).exception;
3573: registre_erreur_systeme =
3574: (*s_etat_processus).erreur_systeme;
3575:
3576: (*s_etat_processus).s_objet_errone = s_objet;
3577: (*s_etat_processus).s_objet_erreur =
3578: (*l_element_courant).donnee;
3579:
3580: l_element_courant = (*l_element_courant).suivant;
3581:
3582: while(l_element_courant != NULL)
3583: {
3584: if ((*(*l_element_courant).donnee).type == FCT)
3585: {
3586: (*s_etat_processus).instruction_courante =
3587: (*((struct_fonction *)
3588: (*(*l_element_courant).donnee)
3589: .objet)).nom_fonction;
3590: fonction = (*((struct_fonction *)
3591: (*(*l_element_courant).donnee)
3592: .objet)).fonction;
3593:
3594: if (recherche_variable(s_etat_processus,
3595: (*s_etat_processus)
3596: .instruction_courante) == d_faux)
3597: {
3598: (*s_etat_processus).erreur_systeme
3599: = d_es;
3600:
3601: /*
3602: * Traitement de la pile système par les
3603: * différentes instructions.
3604: */
3605:
3606: if (TEST(instruction_if) ||
3607: TEST(instruction_iferr) ||
3608: TEST(instruction_do) ||
3609: TEST(instruction_while) ||
3610: TEST(instruction_for) ||
3611: TEST(instruction_start) ||
3612: TEST(instruction_select) ||
3613: TEST(instruction_case) ||
3614: TEST(vers_niveau_superieur))
3615: {
3616: if (TEST(vers_niveau_superieur))
3617: {
3618: analyse(s_etat_processus,
3619: vers_niveau_superieur);
3620:
3621: if ((*s_etat_processus)
3622: .erreur_systeme != d_es)
3623: {
3624: (*s_etat_processus)
3625: .instruction_courante =
3626: instruction_courante;
3627: return(d_erreur);
3628: }
3629: }
3630: else
3631: {
3632: empilement_pile_systeme(
3633: s_etat_processus);
3634:
3635: if ((*s_etat_processus)
3636: .erreur_systeme != d_es)
3637: {
3638: if (presence_egalite ==
3639: d_vrai)
3640: {
3641: liberation(
3642: s_etat_processus,
3643: s_objet_evalue);
3644: }
3645:
3646: (*s_etat_processus)
3647: .instruction_courante =
3648: instruction_courante;
3649: return(d_erreur);
3650: }
3651: }
3652: }
3653: else if (TEST(instruction_end) ||
3654: TEST(instruction_next) ||
3655: TEST(instruction_step) ||
3656: TEST(vers_niveau_inferieur))
3657: {
3658: if (TEST(vers_niveau_inferieur))
3659: {
3660: analyse(s_etat_processus,
3661: vers_niveau_inferieur);
3662:
3663: if ((*s_etat_processus)
3664: .erreur_systeme != d_es)
3665: {
3666: (*s_etat_processus)
3667: .instruction_courante =
3668: instruction_courante;
3669: return(d_erreur);
3670: }
3671: }
3672: else
3673: {
3674: depilement_pile_systeme(
3675: s_etat_processus);
3676:
3677: if ((*s_etat_processus)
3678: .erreur_systeme != d_es)
3679: {
3680: if (presence_egalite ==
3681: d_vrai)
3682: {
3683: liberation(
3684: s_etat_processus,
3685: s_objet_evalue);
3686: }
3687:
3688: (*s_etat_processus)
3689: .instruction_courante =
3690: instruction_courante;
3691: return(d_erreur);
3692: }
3693: }
3694: }
3695: }
3696: }
3697:
3698: l_element_courant =
3699: (*l_element_courant).suivant;
3700: }
3701:
3702: (*s_etat_processus).mode_execution_programme =
3703: registre_mode_execution_programme;
3704: (*s_etat_processus).instruction_courante =
3705: instruction_courante;
3706:
3707: if (presence_egalite == d_vrai)
3708: {
3709: liberation(s_etat_processus, s_objet_evalue);
3710: }
3711:
3712: if ((*s_etat_processus)
3713: .var_volatile_processus_pere == 0)
3714: {
3715: kill((*s_etat_processus)
3716: .pid_processus_pere, SIGALRM);
3717: }
3718: else
3719: {
3720: (*s_etat_processus).var_volatile_alarme = -1;
3721: }
3722:
3723: (*s_etat_processus).erreur_execution =
3724: registre_erreur_execution;
3725: (*s_etat_processus).erreur_systeme =
3726: registre_erreur_systeme;
3727: (*s_etat_processus).exception =
3728: registre_exception;
3729: return(d_erreur);
3730: }
3731: }
3732:
3733: if ((*s_etat_processus).erreur_systeme != d_es)
3734: {
3735: if (presence_egalite == d_vrai)
3736: {
3737: liberation(s_etat_processus, s_objet_evalue);
3738: }
3739:
3740: if ((*s_etat_processus).var_volatile_processus_pere
3741: == 0)
3742: {
3743: kill((*s_etat_processus)
3744: .pid_processus_pere, SIGALRM);
3745: }
3746: else
3747: {
3748: (*s_etat_processus).var_volatile_alarme = -1;
3749: }
3750:
3751: (*s_etat_processus).instruction_courante =
3752: instruction_courante;
3753: return(d_erreur);
3754: }
3755: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3756: ((*s_etat_processus).exception != d_ep))
3757: {
3758: if ((*s_etat_processus).arret_si_exception == d_faux)
3759: {
3760: /*
3761: * Reprise sur erreur
3762: */
3763:
3764: if ((message = messages(s_etat_processus)) == NULL)
3765: {
3766: if (presence_egalite == d_vrai)
3767: {
3768: liberation(s_etat_processus,
3769: s_objet_evalue);
3770: }
3771:
3772: (*s_etat_processus).instruction_courante =
3773: instruction_courante;
3774: return(d_erreur);
3775: }
3776:
3777: free(message);
3778:
3779: while((*(*s_etat_processus).l_base_pile_systeme)
3780: .clause != 'R')
3781: {
3782: l_registre_atome = l_element_courant;
3783: l_element_courant =
3784: (*l_element_courant).suivant;
3785:
3786: if (l_element_courant == NULL)
3787: {
3788: /*
3789: * La fin de l'expression est atteinte,
3790: * le sequenceur reprend la main.
3791: */
3792:
3793: if (presence_egalite == d_vrai)
3794: {
3795: liberation(s_etat_processus,
3796: s_objet_evalue);
3797: }
3798:
3799: (*s_etat_processus)
3800: .mode_execution_programme =
3801: registre_mode_execution_programme;
3802: return(d_absence_erreur);
3803: }
3804:
3805: if ((*(*l_element_courant).donnee).type == FCT)
3806: {
3807: (*s_etat_processus).instruction_courante =
3808: (*((struct_fonction *)
3809: (*(*l_element_courant).donnee)
3810: .objet)).nom_fonction;
3811:
3812: if (recherche_variable(s_etat_processus,
3813: (*s_etat_processus)
3814: .instruction_courante) == d_faux)
3815: {
3816: (*s_etat_processus).erreur_systeme
3817: = d_es;
3818: fonction = (*((struct_fonction *)
3819: (*(*l_element_courant).donnee)
3820: .objet)).fonction;
3821:
3822: /*
3823: * Traitement de la pile système par les
3824: * différentes instructions.
3825: */
3826:
3827: if (TEST(instruction_if) ||
3828: TEST(instruction_iferr) ||
3829: TEST(instruction_do) ||
3830: TEST(instruction_while) ||
3831: TEST(instruction_for) ||
3832: TEST(instruction_start) ||
3833: TEST(instruction_select) ||
3834: TEST(instruction_case) ||
3835: TEST(vers_niveau_superieur))
3836: {
3837: if (TEST(vers_niveau_superieur))
3838: {
3839: registre_exception =
3840: (*s_etat_processus)
3841: .exception;
3842: registre_erreur_execution =
3843: (*s_etat_processus)
3844: .erreur_execution;
3845:
3846: analyse(s_etat_processus,
3847: vers_niveau_superieur);
3848:
3849: if ((*s_etat_processus)
3850: .erreur_systeme != d_es)
3851: {
3852: (*s_etat_processus)
3853: .instruction_courante =
3854: instruction_courante;
3855: return(d_erreur);
3856: }
3857:
3858: (*s_etat_processus).exception
3859: = registre_exception;
3860: (*s_etat_processus)
3861: .erreur_execution =
3862: registre_erreur_execution;
3863: }
3864: else
3865: {
3866: empilement_pile_systeme(
3867: s_etat_processus);
3868:
3869: if ((*s_etat_processus)
3870: .erreur_systeme != d_es)
3871: {
3872: if (presence_egalite ==
3873: d_vrai)
3874: {
3875: liberation(
3876: s_etat_processus,
3877: s_objet_evalue);
3878: }
3879:
3880: (*s_etat_processus)
3881: .instruction_courante =
3882: instruction_courante;
3883: return(d_erreur);
3884: }
3885: }
3886: }
3887: else if (TEST(instruction_end) ||
3888: TEST(instruction_next) ||
3889: TEST(instruction_step) ||
3890: TEST(vers_niveau_inferieur))
3891: {
3892: if (TEST(vers_niveau_inferieur))
3893: {
3894: registre_exception =
3895: (*s_etat_processus)
3896: .exception;
3897: registre_erreur_execution =
3898: (*s_etat_processus)
3899: .erreur_execution;
3900:
3901: analyse(s_etat_processus,
3902: vers_niveau_inferieur);
3903:
3904: if ((*s_etat_processus)
3905: .erreur_systeme != d_es)
3906: {
3907: (*s_etat_processus)
3908: .instruction_courante =
3909: instruction_courante;
3910: return(d_erreur);
3911: }
3912:
3913: (*s_etat_processus).exception
3914: = registre_exception;
3915: (*s_etat_processus)
3916: .erreur_execution =
3917: registre_erreur_execution;
3918: }
3919: else
3920: {
3921: depilement_pile_systeme(
3922: s_etat_processus);
3923:
3924: if ((*s_etat_processus)
3925: .erreur_systeme != d_es)
3926: {
3927: if (presence_egalite ==
3928: d_vrai)
3929: {
3930: liberation(
3931: s_etat_processus,
3932: s_objet_evalue);
3933: }
3934:
3935: (*s_etat_processus)
3936: .instruction_courante =
3937: instruction_courante;
3938: return(d_erreur);
3939: }
3940: }
3941: }
3942: }
3943: }
3944: }
3945:
3946: (*s_etat_processus).instruction_courante =
3947: instruction_courante;
3948: drapeau_then = d_faux;
3949:
3950: do
3951: {
3952: l_registre_atome = l_element_courant;
3953:
3954: if (l_element_courant == NULL)
3955: {
3956: /*
3957: * La fin de l'expression est atteinte,
3958: * le sequenceur reprend la main.
3959: */
3960:
3961: if (presence_egalite == d_vrai)
3962: {
3963: liberation(s_etat_processus,
3964: s_objet_evalue);
3965: }
3966:
3967: (*s_etat_processus)
3968: .mode_execution_programme =
3969: registre_mode_execution_programme;
3970: (*s_etat_processus).instruction_courante =
3971: instruction_courante;
3972: return(d_absence_erreur);
3973: }
3974:
3975: if ((*(*l_element_courant).donnee).type == FCT)
3976: {
3977: (*s_etat_processus)
3978: .instruction_courante =
3979: (*((struct_fonction *)
3980: (*(*l_element_courant).donnee)
3981: .objet)).nom_fonction;
3982: fonction = (*((struct_fonction *)
3983: (*(*l_element_courant).donnee)
3984: .objet)).fonction;
3985: (*s_etat_processus).instruction_courante =
3986: instruction_courante;
3987:
3988: drapeau_then = TEST(instruction_then)
3989: ? d_vrai : d_faux;
3990: }
3991:
3992: l_element_courant = (*l_element_courant)
3993: .suivant;
3994: } while(drapeau_then == d_faux);
3995:
3996: (*s_etat_processus).expression_courante =
3997: l_registre_atome;
3998:
3999: (*(*s_etat_processus).l_base_pile_systeme)
4000: .clause = 'X';
4001: instruction_then(s_etat_processus);
4002:
4003: (*s_etat_processus).exception = d_ep;
4004: (*s_etat_processus).erreur_execution = d_ex;
4005: }
4006: else if ((*s_etat_processus).mode_evaluation_expression
4007: == 'Y')
4008: {
4009: /*
4010: * Reprise sur erreur
4011: */
4012:
4013: while(l_element_courant != NULL)
4014: {
4015: if ((*(*l_element_courant).donnee).type == FCT)
4016: {
4017: (*s_etat_processus).instruction_courante =
4018: (*((struct_fonction *)
4019: (*(*l_element_courant).donnee)
4020: .objet)).nom_fonction;
4021: fonction = (*((struct_fonction *)
4022: (*(*l_element_courant).donnee)
4023: .objet)).fonction;
4024:
4025: if (recherche_variable(s_etat_processus,
4026: (*s_etat_processus)
4027: .instruction_courante) == d_faux)
4028: {
4029: (*s_etat_processus).erreur_systeme
4030: = d_es;
4031:
4032: /*
4033: * Traitement de la pile système par les
4034: * différentes instructions.
4035: */
4036:
4037: if (TEST(instruction_if) ||
4038: TEST(instruction_iferr) ||
4039: TEST(instruction_do) ||
4040: TEST(instruction_while) ||
4041: TEST(instruction_for) ||
4042: TEST(instruction_start) ||
4043: TEST(instruction_select) ||
4044: TEST(instruction_case) ||
4045: TEST(vers_niveau_superieur))
4046: {
4047: if (TEST(vers_niveau_superieur))
4048: {
4049: analyse(s_etat_processus,
4050: vers_niveau_superieur);
4051:
4052: if ((*s_etat_processus)
4053: .erreur_systeme != d_es)
4054: {
4055: (*s_etat_processus)
4056: .instruction_courante =
4057: instruction_courante;
4058: return(d_erreur);
4059: }
4060: }
4061: else
4062: {
4063: empilement_pile_systeme(
4064: s_etat_processus);
4065:
4066: if ((*s_etat_processus)
4067: .erreur_systeme != d_es)
4068: {
4069: if (presence_egalite ==
4070: d_vrai)
4071: {
4072: liberation(
4073: s_etat_processus,
4074: s_objet_evalue);
4075: }
4076:
4077: (*s_etat_processus)
4078: .instruction_courante =
4079: instruction_courante;
4080: return(d_erreur);
4081: }
4082: }
4083: }
4084: else if (TEST(instruction_end) ||
4085: TEST(instruction_next) ||
4086: TEST(instruction_step) ||
4087: TEST(vers_niveau_inferieur))
4088: {
4089: if (TEST(vers_niveau_inferieur))
4090: {
4091: analyse(s_etat_processus,
4092: vers_niveau_inferieur);
4093:
4094: if ((*s_etat_processus)
4095: .erreur_systeme != d_es)
4096: {
4097: (*s_etat_processus)
4098: .instruction_courante =
4099: instruction_courante;
4100: return(d_erreur);
4101: }
4102: }
4103: else
4104: {
4105: depilement_pile_systeme(
4106: s_etat_processus);
4107:
4108: if ((*s_etat_processus)
4109: .erreur_systeme != d_es)
4110: {
4111: if (presence_egalite ==
4112: d_vrai)
4113: {
4114: liberation(
4115: s_etat_processus,
4116: s_objet_evalue);
4117: }
4118:
4119: (*s_etat_processus)
4120: .instruction_courante =
4121: instruction_courante;
4122: return(d_erreur);
4123: }
4124: }
4125: }
4126: }
4127: }
4128:
4129: l_element_courant =
4130: (*l_element_courant).suivant;
4131: }
4132:
4133: (*s_etat_processus).mode_execution_programme =
4134: registre_mode_execution_programme;
4135: (*s_etat_processus).instruction_courante =
4136: instruction_courante;
4137:
4138: (*s_etat_processus).exception = d_ep;
4139: (*s_etat_processus).erreur_execution = d_ex;
4140:
4141: erreur_evaluation = d_erreur;
4142: }
4143: else
4144: {
4145: // On ne détruit pas les variables pour les inclure
4146: // dans le fichier rpl-core.
4147:
4148: (*s_etat_processus).gel_liste_variables = d_vrai;
4149:
4150: registre_erreur_execution =
4151: (*s_etat_processus).erreur_execution;
4152: registre_exception =
4153: (*s_etat_processus).exception;
4154: registre_erreur_systeme =
4155: (*s_etat_processus).erreur_systeme;
4156:
4157: (*s_etat_processus).s_objet_errone = s_objet;
4158: (*s_etat_processus).s_objet_erreur =
4159: (*l_element_courant).donnee;
4160:
4161: l_element_courant = (*l_element_courant).suivant;
4162:
4163: while(l_element_courant != NULL)
4164: {
4165: if ((*(*l_element_courant).donnee).type == FCT)
4166: {
4167: (*s_etat_processus).instruction_courante =
4168: (*((struct_fonction *)
4169: (*(*l_element_courant).donnee)
4170: .objet)).nom_fonction;
4171: fonction = (*((struct_fonction *)
4172: (*(*l_element_courant).donnee)
4173: .objet)).fonction;
4174:
4175: if (recherche_variable(s_etat_processus,
4176: (*s_etat_processus)
4177: .instruction_courante) == d_faux)
4178: {
4179: (*s_etat_processus).erreur_systeme
4180: = d_es;
4181:
4182: /*
4183: * Traitement de la pile système par les
4184: * différentes instructions.
4185: */
4186:
4187: if (TEST(instruction_if) ||
4188: TEST(instruction_iferr) ||
4189: TEST(instruction_do) ||
4190: TEST(instruction_while) ||
4191: TEST(instruction_for) ||
4192: TEST(instruction_start) ||
4193: TEST(instruction_select) ||
4194: TEST(instruction_case) ||
4195: TEST(vers_niveau_superieur))
4196: {
4197: if (TEST(vers_niveau_superieur))
4198: {
4199: analyse(s_etat_processus,
4200: vers_niveau_superieur);
4201:
4202: if ((*s_etat_processus)
4203: .erreur_systeme != d_es)
4204: {
4205: (*s_etat_processus)
4206: .instruction_courante =
4207: instruction_courante;
4208: return(d_erreur);
4209: }
4210: }
4211: else
4212: {
4213: empilement_pile_systeme(
4214: s_etat_processus);
4215:
4216: if ((*s_etat_processus)
4217: .erreur_systeme != d_es)
4218: {
4219: if (presence_egalite ==
4220: d_vrai)
4221: {
4222: liberation(
4223: s_etat_processus,
4224: s_objet_evalue);
4225: }
4226:
4227: (*s_etat_processus)
4228: .instruction_courante =
4229: instruction_courante;
4230: return(d_erreur);
4231: }
4232: }
4233: }
4234: else if (TEST(instruction_end) ||
4235: TEST(instruction_next) ||
4236: TEST(instruction_step) ||
4237: TEST(vers_niveau_inferieur))
4238: {
4239: if (TEST(vers_niveau_inferieur))
4240: {
4241: analyse(s_etat_processus,
4242: vers_niveau_inferieur);
4243:
4244: if ((*s_etat_processus)
4245: .erreur_systeme != d_es)
4246: {
4247: (*s_etat_processus)
4248: .instruction_courante =
4249: instruction_courante;
4250: return(d_erreur);
4251: }
4252: }
4253: else
4254: {
4255: depilement_pile_systeme(
4256: s_etat_processus);
4257:
4258: if ((*s_etat_processus)
4259: .erreur_systeme != d_es)
4260: {
4261: if (presence_egalite ==
4262: d_vrai)
4263: {
4264: liberation(
4265: s_etat_processus,
4266: s_objet_evalue);
4267: }
4268:
4269: (*s_etat_processus)
4270: .instruction_courante =
4271: instruction_courante;
4272: return(d_erreur);
4273: }
4274: }
4275: }
4276: }
4277: }
4278:
4279: l_element_courant =
4280: (*l_element_courant).suivant;
4281: }
4282:
4283: (*s_etat_processus).mode_execution_programme =
4284: registre_mode_execution_programme;
4285: (*s_etat_processus).instruction_courante =
4286: instruction_courante;
4287:
4288: if (presence_egalite == d_vrai)
4289: {
4290: liberation(s_etat_processus, s_objet_evalue);
4291: }
4292:
4293: if ((*s_etat_processus)
4294: .var_volatile_processus_pere == 0)
4295: {
4296: kill((*s_etat_processus)
4297: .pid_processus_pere, SIGALRM);
4298: }
4299: else
4300: {
4301: (*s_etat_processus).var_volatile_alarme = -1;
4302: }
4303:
4304: (*s_etat_processus).erreur_execution =
4305: registre_erreur_execution;
4306: (*s_etat_processus).erreur_systeme =
4307: registre_erreur_systeme;
4308: (*s_etat_processus).exception =
4309: registre_exception;
4310: return(d_erreur);
4311: }
4312: }
4313: }
4314: else if ((*s_etat_processus).constante_symbolique == 'N')
4315: {
4316: if ((s_objet_elementaire = copie_objet(s_etat_processus,
4317: (*l_element_courant).donnee, 'P')) == NULL)
4318: {
4319: if (presence_egalite == d_vrai)
4320: {
4321: liberation(s_etat_processus, s_objet_evalue);
4322: }
4323:
4324: (*s_etat_processus).erreur_systeme =
4325: d_es_allocation_memoire;
4326: (*s_etat_processus).instruction_courante =
4327: instruction_courante;
4328: return(d_erreur);
4329: }
4330:
4331: presence_fonction = d_faux;
4332: presence_variable_partagee = d_faux;
4333:
4334: if (recherche_variable(s_etat_processus, (*((struct_nom *)
4335: (*s_objet_elementaire).objet)).nom) == d_faux)
4336: {
4337: (*s_etat_processus).erreur_systeme = d_es;
4338: presence_variable = d_faux;
4339: }
4340: else
4341: {
4342: if ((*s_etat_processus).traitement_symbolique == 'N')
4343: {
4344: if ((*s_etat_processus).s_liste_variables
4345: [(*s_etat_processus)
4346: .position_variable_courante].objet == NULL)
4347: {
4348: // Variable partagée
4349:
4350: if (pthread_mutex_lock(&((*(*s_etat_processus)
4351: .s_liste_variables_partagees).mutex))
4352: != 0)
4353: {
4354: (*s_etat_processus).erreur_systeme =
4355: d_es_processus;
4356: return(d_erreur);
4357: }
4358:
4359: presence_variable_partagee = d_faux;
4360:
4361: if (recherche_variable_partagee(
4362: s_etat_processus,
4363: ((*s_etat_processus).s_liste_variables
4364: [(*s_etat_processus)
4365: .position_variable_courante]).nom,
4366: ((*s_etat_processus).s_liste_variables
4367: [(*s_etat_processus)
4368: .position_variable_courante])
4369: .variable_partagee, 'E') == d_vrai)
4370: {
4371: presence_variable = d_vrai;
4372: presence_variable_partagee = d_vrai;
4373:
4374: if ((*((*(*s_etat_processus)
4375: .s_liste_variables_partagees).table
4376: [(*(*s_etat_processus)
4377: .s_liste_variables_partagees)
4378: .position_variable].objet)).type
4379: == ADR)
4380: {
4381: presence_fonction = d_vrai;
4382: }
4383:
4384: if ((type_evaluation == 'N') ||
4385: ((*((struct_nom *)
4386: (*(*l_element_courant).donnee)
4387: .objet)).symbole == d_faux))
4388: {
4389: if ((s_copie_variable_partagee =
4390: copie_objet(s_etat_processus,
4391: (*(*s_etat_processus)
4392: .s_liste_variables_partagees)
4393: .table[(*(*s_etat_processus)
4394: .s_liste_variables_partagees)
4395: .position_variable].objet, 'P'))
4396: == NULL)
4397: {
4398: if (pthread_mutex_unlock(
4399: &((*(*s_etat_processus)
4400: .s_liste_variables_partagees
4401: ).mutex)) != 0)
4402: {
4403: (*s_etat_processus)
4404: .erreur_systeme =
4405: d_es_processus;
4406: return(d_erreur);
4407: }
4408: }
4409: }
4410: else
4411: {
4412: s_copie_variable_partagee = NULL;
4413: }
4414:
4415: if (pthread_mutex_unlock(
4416: &((*(*s_etat_processus)
4417: .s_liste_variables_partagees)
4418: .mutex)) != 0)
4419: {
4420: (*s_etat_processus).erreur_systeme =
4421: d_es_processus;
4422: return(d_erreur);
4423: }
4424: }
4425: else
4426: {
4427: (*s_etat_processus).erreur_systeme = d_es;
4428: presence_variable = d_faux;
4429: presence_variable_partagee = d_faux;
4430:
4431: if (pthread_mutex_unlock(
4432: &((*(*s_etat_processus)
4433: .s_liste_variables_partagees)
4434: .mutex)) != 0)
4435: {
4436: (*s_etat_processus).erreur_systeme =
4437: d_es_processus;
4438: return(d_erreur);
4439: }
4440: }
4441: }
4442: else
4443: {
4444: presence_variable = d_vrai;
4445:
4446: if ((*((*s_etat_processus)
4447: .s_liste_variables
4448: [(*s_etat_processus)
4449: .position_variable_courante]
4450: .objet)).type == ADR)
4451: {
4452: presence_fonction = d_vrai;
4453: }
4454: }
4455: }
4456: else
4457: {
4458: presence_variable = d_faux;
4459: }
4460: }
4461:
4462: liberation(s_etat_processus, s_objet_elementaire);
4463:
4464: if (presence_fonction == d_vrai)
4465: {
4466: autorisation_empilement_programme = (*s_etat_processus)
4467: .autorisation_empilement_programme;
4468: registre_position_courante = (*s_etat_processus)
4469: .position_courante;
4470:
4471: empilement_pile_systeme(s_etat_processus);
4472:
4473: if ((*s_etat_processus).erreur_systeme != d_es)
4474: {
4475: if (presence_variable_partagee == d_vrai)
4476: {
4477: liberation(s_etat_processus,
4478: s_copie_variable_partagee);
4479: }
4480:
4481: if (presence_egalite == d_vrai)
4482: {
4483: liberation(s_etat_processus, s_objet_evalue);
4484: }
4485:
4486: (*s_etat_processus).instruction_courante =
4487: instruction_courante;
4488: return(d_erreur);
4489: }
4490:
4491: (*(*s_etat_processus).l_base_pile_systeme)
4492: .retour_definition = 'Y';
4493: (*(*s_etat_processus).l_base_pile_systeme)
4494: .origine_routine_evaluation = 'Y';
4495:
4496: (*s_etat_processus).mode_execution_programme = 'Y';
4497: (*s_etat_processus).autorisation_empilement_programme
4498: = 'N';
4499:
4500: (*(*s_etat_processus).l_base_pile_systeme)
4501: .niveau_courant = (*s_etat_processus)
4502: .niveau_courant;
4503:
4504: if (presence_variable_partagee == d_faux)
4505: {
4506: (*s_etat_processus).position_courante =
4507: (*((unsigned long *)
4508: ((*((*s_etat_processus).s_liste_variables
4509: [(*s_etat_processus)
4510: .position_variable_courante]
4511: .objet)).objet)));
4512: }
4513: else
4514: {
4515: (*s_etat_processus).position_courante =
4516: (*((unsigned long *)
4517: (*s_copie_variable_partagee).objet));
4518: liberation(s_etat_processus,
4519: s_copie_variable_partagee);
4520: }
4521:
4522: if ((*s_etat_processus).profilage == d_vrai)
4523: {
4524: profilage(s_etat_processus,
4525: (*s_etat_processus).s_liste_variables
4526: [(*s_etat_processus)
4527: .position_variable_courante].nom);
4528:
4529: if ((*s_etat_processus).erreur_systeme != d_es)
4530: {
4531: return(d_erreur);
4532: }
4533: }
4534:
4535: if (sequenceur(s_etat_processus) == d_erreur)
4536: {
4537: if (presence_egalite == d_vrai)
4538: {
4539: liberation(s_etat_processus, s_objet_evalue);
4540: }
4541:
4542: (*s_etat_processus).instruction_courante =
4543: instruction_courante;
4544: (*s_etat_processus).mode_execution_programme =
4545: registre_mode_execution_programme;
4546: return(d_erreur);
4547: }
4548:
4549: (*s_etat_processus).instruction_courante =
4550: instruction_courante;
4551: (*s_etat_processus).mode_execution_programme = 'N';
4552:
4553: depilement_pile_systeme(s_etat_processus);
4554:
4555: if ((*s_etat_processus).erreur_systeme != d_es)
4556: {
4557: if (presence_egalite == d_vrai)
4558: {
4559: liberation(s_etat_processus, s_objet_evalue);
4560: }
4561:
4562: return(d_erreur);
4563: }
4564:
4565: (*s_etat_processus).retour_routine_evaluation = 'N';
4566: (*s_etat_processus).position_courante =
4567: registre_position_courante;
4568: (*s_etat_processus).autorisation_empilement_programme =
4569: autorisation_empilement_programme;
4570: }
4571: else if (((type_evaluation == 'N') || ((*((struct_nom *)
4572: (*(*l_element_courant).donnee).objet)).symbole ==
4573: d_faux)) && (presence_variable == d_vrai))
4574: {
4575: if (type_evaluation == 'I')
4576: {
4577: if (presence_variable_partagee == d_faux)
4578: {
4579: if ((s_sous_objet =
4580: copie_objet(s_etat_processus,
4581: (*s_etat_processus)
4582: .s_liste_variables[(*s_etat_processus)
4583: .position_variable_courante].objet,
4584: 'P')) == NULL)
4585: {
4586: if (presence_variable_partagee == d_vrai)
4587: {
4588: liberation(s_etat_processus,
4589: s_copie_variable_partagee);
4590: }
4591:
4592: if (presence_egalite == d_vrai)
4593: {
4594: liberation(s_etat_processus,
4595: s_objet_evalue);
4596: }
4597:
4598: (*s_etat_processus).erreur_systeme =
4599: d_es_allocation_memoire;
4600: (*s_etat_processus).instruction_courante =
4601: instruction_courante;
4602: return(d_erreur);
4603: }
4604:
4605: if (empilement(s_etat_processus,
4606: &((*s_etat_processus).l_base_pile),
4607: s_sous_objet) == d_erreur)
4608: {
4609: if (presence_variable_partagee == d_vrai)
4610: {
4611: liberation(s_etat_processus,
4612: s_copie_variable_partagee);
4613: }
4614:
4615: if (presence_egalite == d_vrai)
4616: {
4617: liberation(s_etat_processus,
4618: s_objet_evalue);
4619: }
4620:
4621: return(d_erreur);
4622: }
4623: }
4624: else
4625: {
4626: if (empilement(s_etat_processus,
4627: &((*s_etat_processus).l_base_pile),
4628: s_copie_variable_partagee) == d_erreur)
4629: {
4630: if (presence_variable_partagee == d_vrai)
4631: {
4632: liberation(s_etat_processus,
4633: s_copie_variable_partagee);
4634: }
4635:
4636: if (presence_egalite == d_vrai)
4637: {
4638: liberation(s_etat_processus,
4639: s_objet_evalue);
4640: }
4641:
4642: return(d_erreur);
4643: }
4644: }
4645: }
4646: else
4647: {
4648: registre_evaluation_expression_compilee =
4649: (*s_etat_processus)
4650: .evaluation_expression_compilee;
4651:
4652: if (((*s_etat_processus).s_liste_variables
4653: [(*s_etat_processus)
4654: .position_variable_courante].origine == 'E')
4655: && ((*s_etat_processus).s_liste_variables
4656: [(*s_etat_processus)
4657: .position_variable_courante].niveau == 0))
4658: {
4659: (*s_etat_processus)
4660: .evaluation_expression_compilee = 'Y';
4661: }
4662: else
4663: {
4664: (*s_etat_processus)
4665: .evaluation_expression_compilee = 'N';
4666: }
4667:
4668: if (presence_variable_partagee == d_faux)
4669: {
4670: if ((*s_etat_processus).profilage == d_vrai)
4671: {
4672: profilage(s_etat_processus,
4673: (*s_etat_processus)
4674: .s_liste_variables
4675: [(*s_etat_processus)
4676: .position_variable_courante].nom);
4677:
4678: if ((*s_etat_processus).erreur_systeme
4679: != d_es)
4680: {
4681: return(d_erreur);
4682: }
4683: }
4684:
4685: registre_niveau_courant = (*(*s_etat_processus)
4686: .l_base_pile_systeme).niveau_courant;
4687: registre_retour_definition =
4688: (*(*s_etat_processus)
4689: .l_base_pile_systeme).retour_definition;
4690:
4691: (*(*s_etat_processus).l_base_pile_systeme)
4692: .retour_definition = 'Y';
4693: (*(*s_etat_processus).l_base_pile_systeme)
4694: .niveau_courant = (*s_etat_processus)
4695: .niveau_courant;
4696: empilement_pile_systeme(s_etat_processus);
4697:
4698: if (evaluation(s_etat_processus,
4699: (*s_etat_processus)
4700: .s_liste_variables[(*s_etat_processus)
4701: .position_variable_courante].objet,
4702: type_evaluation) == d_erreur)
4703: {
4704: depilement_pile_systeme(s_etat_processus);
4705:
4706: (*(*s_etat_processus).l_base_pile_systeme)
4707: .niveau_courant =
4708: (*(*s_etat_processus).l_base_pile_systeme)
4709: .retour_definition =
4710: registre_retour_definition;
4711:
4712: if ((*s_etat_processus).profilage == d_vrai)
4713: {
4714: profilage(s_etat_processus, NULL);
4715: }
4716:
4717: (*s_etat_processus)
4718: .evaluation_expression_compilee =
4719: registre_evaluation_expression_compilee;
4720:
4721: if (presence_egalite == d_vrai)
4722: {
4723: liberation(s_etat_processus,
4724: s_objet_evalue);
4725: }
4726:
4727: (*s_etat_processus).instruction_courante =
4728: instruction_courante;
4729: (*s_etat_processus).mode_execution_programme
4730: = registre_mode_execution_programme;
4731: return(d_erreur);
4732: }
4733:
4734: depilement_pile_systeme(s_etat_processus);
4735:
4736: (*(*s_etat_processus).l_base_pile_systeme)
4737: .niveau_courant =
4738: (*(*s_etat_processus).l_base_pile_systeme)
4739: .retour_definition =
4740: registre_retour_definition;
4741: }
4742: else
4743: {
4744: if ((*s_etat_processus).profilage == d_vrai)
4745: {
4746: profilage(s_etat_processus,
4747: (*s_etat_processus)
4748: .s_liste_variables
4749: [(*s_etat_processus)
4750: .position_variable_courante].nom);
4751:
4752: if ((*s_etat_processus).erreur_systeme
4753: != d_es)
4754: {
4755: return(d_erreur);
4756: }
4757: }
4758:
4759: empilement_pile_systeme(s_etat_processus);
4760: (*(*s_etat_processus).l_base_pile_systeme)
4761: .retour_definition = 'Y';
4762: (*(*s_etat_processus).l_base_pile_systeme)
4763: .niveau_courant = (*s_etat_processus)
4764: .niveau_courant;
4765: empilement_pile_systeme(s_etat_processus);
4766:
4767: if (evaluation(s_etat_processus,
4768: s_copie_variable_partagee,
4769: type_evaluation) == d_erreur)
4770: {
4771: depilement_pile_systeme(s_etat_processus);
4772: depilement_pile_systeme(s_etat_processus);
4773:
4774: liberation(s_etat_processus,
4775: s_copie_variable_partagee);
4776:
4777: if ((*s_etat_processus).profilage == d_vrai)
4778: {
4779: profilage(s_etat_processus, NULL);
4780: }
4781:
4782: (*s_etat_processus)
4783: .evaluation_expression_compilee =
4784: registre_evaluation_expression_compilee;
4785:
4786: if (presence_egalite == d_vrai)
4787: {
4788: liberation(s_etat_processus,
4789: s_objet_evalue);
4790: }
4791:
4792: (*s_etat_processus).instruction_courante =
4793: instruction_courante;
4794: (*s_etat_processus).mode_execution_programme
4795: = registre_mode_execution_programme;
4796: return(d_erreur);
4797: }
4798:
4799: depilement_pile_systeme(s_etat_processus);
4800: depilement_pile_systeme(s_etat_processus);
4801:
4802: liberation(s_etat_processus,
4803: s_copie_variable_partagee);
4804: }
4805:
4806: if ((*s_etat_processus).profilage == d_vrai)
4807: {
4808: profilage(s_etat_processus, NULL);
4809: }
4810:
4811: (*s_etat_processus)
4812: .evaluation_expression_compilee =
4813: registre_evaluation_expression_compilee;
4814: }
4815: }
4816: else
4817: {
4818: if (presence_variable_partagee == d_vrai)
4819: {
4820: liberation(s_etat_processus,
4821: s_copie_variable_partagee);
4822: }
4823:
4824: if ((s_objet_elementaire =
4825: copie_objet(s_etat_processus,
4826: (*l_element_courant).donnee, 'P')) == NULL)
4827: {
4828: if (presence_egalite == d_vrai)
4829: {
4830: liberation(s_etat_processus, s_objet_evalue);
4831: }
4832:
4833: (*s_etat_processus).erreur_systeme =
4834: d_es_allocation_memoire;
4835: (*s_etat_processus).instruction_courante =
4836: instruction_courante;
4837: return(d_erreur);
4838: }
4839:
4840: /*
4841: * Vérification du drapeau symbole pour
4842: * savoir si l'on met dans la pile le nom
4843: * ou le contenu de la variable.
4844: */
4845:
4846: if (((*((struct_nom *) (*s_objet_elementaire).objet))
4847: .symbole == d_faux) && ((*s_etat_processus)
4848: .traitement_symbolique == 'N'))
4849: {
4850: if (recherche_variable(s_etat_processus,
4851: (*((struct_nom *) (*s_objet_elementaire)
4852: .objet)).nom) == d_vrai)
4853: {
4854: if ((*s_etat_processus).s_liste_variables
4855: [(*s_etat_processus)
4856: .position_variable_courante].objet
4857: == NULL)
4858: {
4859: // Variable partagée
4860:
4861: if (pthread_mutex_lock(
4862: &((*(*s_etat_processus)
4863: .s_liste_variables_partagees)
4864: .mutex)) != 0)
4865: {
4866: (*s_etat_processus).erreur_systeme =
4867: d_es_processus;
4868: return(d_erreur);
4869: }
4870:
4871: if (recherche_variable_partagee(
4872: s_etat_processus,
4873: ((*s_etat_processus)
4874: .s_liste_variables
4875: [(*s_etat_processus)
4876: .position_variable_courante]).nom,
4877: ((*s_etat_processus)
4878: .s_liste_variables
4879: [(*s_etat_processus)
4880: .position_variable_courante])
4881: .variable_partagee, 'E') == d_vrai)
4882: {
4883: liberation(s_etat_processus,
4884: s_objet_elementaire);
4885:
4886: if ((s_objet_elementaire =
4887: copie_objet(s_etat_processus,
4888: (*(*s_etat_processus)
4889: .s_liste_variables_partagees)
4890: .table[(*(*s_etat_processus)
4891: .s_liste_variables_partagees)
4892: .position_variable].objet,
4893: 'P')) == NULL)
4894: {
4895: if (pthread_mutex_unlock(
4896: &((*(*s_etat_processus)
4897: .s_liste_variables_partagees
4898: ).mutex)) != 0)
4899: {
4900: (*s_etat_processus)
4901: .erreur_systeme =
4902: d_es_processus;
4903: return(d_erreur);
4904: }
4905:
4906: if (presence_egalite == d_vrai)
4907: {
4908: liberation(s_etat_processus,
4909: s_objet_evalue);
4910: }
4911:
4912: (*s_etat_processus).erreur_systeme =
4913: d_es_allocation_memoire;
4914: (*s_etat_processus)
4915: .instruction_courante =
4916: instruction_courante;
4917: return(d_erreur);
4918: }
4919: }
4920:
4921: if (pthread_mutex_unlock(
4922: &((*(*s_etat_processus)
4923: .s_liste_variables_partagees)
4924: .mutex)) != 0)
4925: {
4926: (*s_etat_processus).erreur_systeme =
4927: d_es_processus;
4928: return(d_erreur);
4929: }
4930: }
4931: else
4932: {
4933: // Variable privée
4934:
4935: liberation(s_etat_processus,
4936: s_objet_elementaire);
4937:
4938: if ((s_objet_elementaire =
4939: copie_objet(s_etat_processus,
4940: (*s_etat_processus)
4941: .s_liste_variables
4942: [(*s_etat_processus)
4943: .position_variable_courante].objet,
4944: 'P')) == NULL)
4945: {
4946: if (presence_egalite == d_vrai)
4947: {
4948: liberation(s_etat_processus,
4949: s_objet_evalue);
4950: }
4951:
4952: (*s_etat_processus).erreur_systeme =
4953: d_es_allocation_memoire;
4954: (*s_etat_processus)
4955: .instruction_courante =
4956: instruction_courante;
4957: return(d_erreur);
4958: }
4959: }
4960: }
4961: else
4962: {
4963: (*s_etat_processus).erreur_systeme = d_es;
4964:
4965: (*((struct_nom *) (*s_objet_elementaire)
4966: .objet)).symbole = d_vrai;
4967: }
4968: }
4969:
4970: if (empilement(s_etat_processus, &((*s_etat_processus)
4971: .l_base_pile), s_objet_elementaire) == d_erreur)
4972: {
4973: if (presence_egalite == d_vrai)
4974: {
4975: liberation(s_etat_processus, s_objet_evalue);
4976: }
4977:
4978: (*s_etat_processus).instruction_courante =
4979: instruction_courante;
4980: return(d_erreur);
4981: }
4982:
4983: if ((*s_etat_processus).erreur_execution ==
4984: d_ex_variable_non_definie)
4985: {
4986: (*s_etat_processus).erreur_execution = d_ex;
4987: }
4988: }
4989: }
4990: else
4991: {
4992: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
4993: == d_vrai) ? 'E' : 'N';
4994:
4995: if (type_evaluation == 'N')
4996: {
4997: cf(s_etat_processus, 35);
4998: }
4999: else
5000: {
5001: sf(s_etat_processus, 35);
5002: }
5003:
5004: analyse(s_etat_processus, NULL);
5005:
5006: if (registre_type_evaluation == 'E')
5007: {
5008: sf(s_etat_processus, 35);
5009: }
5010: else
5011: {
5012: cf(s_etat_processus, 35);
5013: }
5014:
5015: if (((*s_etat_processus).erreur_systeme != d_es) ||
5016: ((*s_etat_processus).erreur_execution != d_ex) ||
5017: ((*s_etat_processus).exception != d_ep))
5018: {
5019: if (presence_egalite == d_vrai)
5020: {
5021: liberation(s_etat_processus, s_objet_evalue);
5022: }
5023:
5024: (*s_etat_processus).instruction_courante =
5025: instruction_courante;
5026: (*s_etat_processus).mode_execution_programme =
5027: registre_mode_execution_programme;
5028: return(d_erreur);
5029: }
5030: }
5031:
5032: (*s_etat_processus).instruction_courante =
5033: instruction_courante;
5034: (*s_etat_processus).test_instruction = registre_test;
5035: (*s_etat_processus).instruction_valide =
5036: registre_instruction_valide;
5037: }
5038: else
5039: {
5040: if ((s_objet_tampon = copie_objet(s_etat_processus,
5041: (*l_element_courant).donnee, 'P')) == NULL)
5042: {
5043: (*s_etat_processus).erreur_systeme =
5044: d_es_allocation_memoire;
5045: (*s_etat_processus).instruction_courante =
5046: instruction_courante;
5047: return(d_erreur);
5048: }
5049:
5050: if (empilement(s_etat_processus, &((*s_etat_processus)
5051: .l_base_pile), s_objet_tampon) == d_erreur)
5052: {
5053: if (presence_egalite == d_vrai)
5054: {
5055: liberation(s_etat_processus, s_objet_evalue);
5056: }
5057:
5058: (*s_etat_processus).instruction_courante =
5059: instruction_courante;
5060: return(d_erreur);
5061: }
5062: }
5063:
5064: // Traitement de l'instruction EXIT en mode interactif
5065:
5066: if (l_element_courant != NULL)
5067: {
5068: l_element_courant = (*l_element_courant).suivant;
5069: }
5070: else
5071: {
5072: (*s_etat_processus).mode_execution_programme = 'Y';
5073:
5074: if ((*s_etat_processus).niveau_courant == 1)
5075: {
5076: (*s_etat_processus).debug_programme = d_faux;
5077: (*s_etat_processus).execution_pas_suivant = d_vrai;
5078: }
5079: }
5080:
5081: if ((*s_etat_processus).traitement_cycle_exit != 'N')
5082: {
5083: registre_expression_courante =
5084: (*s_etat_processus).expression_courante;
5085: (*s_etat_processus).expression_courante =
5086: l_element_courant;
5087:
5088: switch((*s_etat_processus).traitement_cycle_exit)
5089: {
5090: case 'C' :
5091: {
5092: instruction_cycle(s_etat_processus);
5093: break;
5094: }
5095:
5096: case 'E' :
5097: {
5098: instruction_exit(s_etat_processus);
5099: break;
5100: }
5101: }
5102:
5103: l_element_courant = (*s_etat_processus).expression_courante;
5104: (*s_etat_processus).expression_courante =
5105: registre_expression_courante;
5106: }
5107: }
5108:
5109: if (niveau_initial < (*s_etat_processus).niveau_courant)
5110: {
5111: /*
5112: * Retrait des variables dans le cas où l'évaluation de
5113: * l'expression a été interrompue
5114: */
5115:
5116: (*s_etat_processus).niveau_courant = niveau_initial;
5117:
5118: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5119: {
5120: if ((*s_etat_processus).s_liste_variables[n].niveau
5121: > niveau_initial)
5122: {
5123: m++;
5124: }
5125: }
5126:
5127: registre_variables = (*s_etat_processus).s_liste_variables;
5128: (*s_etat_processus).nombre_variables -= m;
5129:
5130: if (((*s_etat_processus).s_liste_variables = malloc(
5131: (*s_etat_processus).nombre_variables *
5132: sizeof(struct_variable))) == NULL)
5133: {
5134: if (presence_egalite == d_vrai)
5135: {
5136: liberation(s_etat_processus, s_objet_evalue);
5137: }
5138:
5139: (*s_etat_processus).instruction_courante = instruction_courante;
5140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5141: return(d_erreur);
5142: }
5143:
5144: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5145: {
5146: if (registre_variables[n + m].niveau > niveau_initial)
5147: {
5148: free(registre_variables[n + m].nom);
5149: liberation(s_etat_processus,
5150: registre_variables[n + m].objet);
5151: m++;
5152: n--;
5153: }
5154: else
5155: {
5156: (*s_etat_processus).s_liste_variables[n] =
5157: registre_variables[n + m];
5158: }
5159: }
5160:
5161: free(registre_variables);
5162: }
5163:
5164: /*
5165: * Retrait des variables statiques créées dans l'expression
5166: */
5167:
5168: for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
5169: {
5170: if ((*s_etat_processus).s_liste_variables_statiques[n]
5171: .niveau > (*s_etat_processus).niveau_courant)
5172: {
5173: if (retrait_variable_statique(s_etat_processus,
5174: (*s_etat_processus).s_liste_variables_statiques[n].nom,
5175: (*s_etat_processus).s_liste_variables_statiques[n]
5176: .variable_statique) == d_erreur)
5177: {
5178: if (presence_egalite == d_vrai)
5179: {
5180: liberation(s_etat_processus, s_objet_evalue);
5181: }
5182:
5183: (*s_etat_processus).instruction_courante =
5184: instruction_courante;
5185: (*s_etat_processus).mode_execution_programme =
5186: registre_mode_execution_programme;
5187: return(d_erreur);
5188: }
5189: }
5190: }
5191:
5192: /*
5193: * Retrait des variables partagées créées dans l'expression
5194: */
5195:
5196: if (pthread_mutex_lock(&((*(*s_etat_processus)
5197: .s_liste_variables_partagees).mutex)) != 0)
5198: {
5199: (*s_etat_processus).erreur_systeme = d_es_processus;
5200: return(d_erreur);
5201: }
5202:
5203: for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
5204: .nombre_variables; n++)
5205: {
5206: if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
5207: .niveau > (*s_etat_processus).niveau_courant)
5208: {
5209: if (retrait_variable_partagee(s_etat_processus,
5210: (*(*s_etat_processus).s_liste_variables_partagees)
5211: .table[n].nom, (*(*s_etat_processus)
5212: .s_liste_variables_partagees).table[n]
5213: .variable_partagee) == d_erreur)
5214: {
5215: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5216: .s_liste_variables_partagees).mutex)) != 0)
5217: {
5218: (*s_etat_processus).erreur_systeme = d_es_processus;
5219: return(d_erreur);
5220: }
5221:
5222: if (presence_egalite == d_vrai)
5223: {
5224: liberation(s_etat_processus, s_objet_evalue);
5225: }
5226:
5227: (*s_etat_processus).instruction_courante =
5228: instruction_courante;
5229: (*s_etat_processus).mode_execution_programme =
5230: registre_mode_execution_programme;
5231: return(d_erreur);
5232: }
5233: }
5234: }
5235:
5236: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5237: .s_liste_variables_partagees).mutex)) != 0)
5238: {
5239: (*s_etat_processus).erreur_systeme = d_es_processus;
5240: return(d_erreur);
5241: }
5242:
5243: if ((*s_etat_processus).var_volatile_requete_arret != 0)
5244: {
5245: // Restauration de la pile système
5246:
5247: while(pile_systeme_originelle !=
5248: (*s_etat_processus).l_base_pile_systeme)
5249: {
5250: depilement_pile_systeme(s_etat_processus);
5251: }
5252: }
5253:
5254: if (presence_egalite == d_vrai)
5255: {
5256: // Ajout du membre évalué lors de la première passe
5257:
5258: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5259: s_objet_evalue) == d_erreur)
5260: {
5261: (*s_etat_processus).instruction_courante =
5262: instruction_courante;
5263: return(d_erreur);
5264: }
5265:
5266: instruction_swap(s_etat_processus);
5267:
5268: if ((*s_etat_processus).erreur_execution != d_ex)
5269: {
5270: (*s_etat_processus).mode_execution_programme =
5271: registre_mode_execution_programme;
5272: (*s_etat_processus).autorisation_empilement_programme =
5273: autorisation_empilement_programme;
5274: (*s_etat_processus).instruction_courante = instruction_courante;
5275: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5276: registre_retour_definition;
5277:
5278: return(d_erreur);
5279: }
5280:
5281: instruction_egalite(s_etat_processus);
5282:
5283: if ((*s_etat_processus).erreur_execution != d_ex)
5284: {
5285: (*s_etat_processus).mode_execution_programme =
5286: registre_mode_execution_programme;
5287: (*s_etat_processus).autorisation_empilement_programme =
5288: autorisation_empilement_programme;
5289: (*s_etat_processus).instruction_courante = instruction_courante;
5290: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5291: registre_retour_definition;
5292:
5293: return(d_erreur);
5294: }
5295: }
5296:
5297: (*s_etat_processus).autorisation_empilement_programme =
5298: autorisation_empilement_programme;
5299: (*s_etat_processus).instruction_courante = instruction_courante;
5300: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5301: registre_retour_definition;
5302: }
5303: else if ((*s_objet).type == FCT)
5304: {
5305: (*s_etat_processus).instruction_courante =
5306: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
5307:
5308: analyse(s_etat_processus, (*((struct_fonction *)
5309: (*s_objet).objet)).fonction);
5310:
5311: (*s_etat_processus).instruction_courante = instruction_courante;
5312:
5313: if (((*s_etat_processus).erreur_systeme != d_es) ||
5314: ((*s_etat_processus).erreur_execution != d_ex) ||
5315: ((*s_etat_processus).exception != d_ep))
5316: {
5317: (*s_etat_processus).instruction_courante = instruction_courante;
5318: (*s_etat_processus).mode_execution_programme =
5319: registre_mode_execution_programme;
5320: return(d_erreur);
5321: }
5322: }
5323: else
5324: {
5325: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
5326: == NULL)
5327: {
5328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5329: (*s_etat_processus).instruction_courante = instruction_courante;
5330: return(d_erreur);
5331: }
5332:
5333: if (empilement(s_etat_processus, &((*s_etat_processus)
5334: .l_base_pile), s_objet_tampon) == d_erreur)
5335: {
5336: (*s_etat_processus).instruction_courante = instruction_courante;
5337: return(d_erreur);
5338: }
5339: }
5340:
5341: (*s_etat_processus).mode_execution_programme =
5342: registre_mode_execution_programme;
5343:
5344: return((erreur_evaluation == d_absence_erreur)
5345: ? d_absence_erreur : d_erreur);
5346: }
5347:
5348: // vim: ts=4