![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to evaluation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to evaluation.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.2 ! bertrand 3: RPL/2 (R) version 4.0.10
1.1 bertrand 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:
1.2 ! bertrand 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:
1.1 bertrand 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:
1.2 ! bertrand 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:
1.1 bertrand 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);
1.2 ! bertrand 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: }
1.1 bertrand 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);
1.2 ! bertrand 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: }
1.1 bertrand 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);
1.2 ! bertrand 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: }
1.1 bertrand 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);
1.2 ! bertrand 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: }
1.1 bertrand 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;
1.2 ! bertrand 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: (*s_etat_processus).expression_courante =
! 3563: registre_expression_courante;
! 3564: }
! 3565: else
! 3566: {
! 3567: // On ne détruit pas les variables pour les inclure
! 3568: // dans le fichier rpl-core.
! 3569:
! 3570: (*s_etat_processus).gel_liste_variables = d_vrai;
! 3571:
! 3572: registre_erreur_execution =
! 3573: (*s_etat_processus).erreur_execution;
! 3574: registre_exception =
! 3575: (*s_etat_processus).exception;
! 3576: registre_erreur_systeme =
! 3577: (*s_etat_processus).erreur_systeme;
! 3578:
! 3579: (*s_etat_processus).s_objet_errone = s_objet;
! 3580: (*s_etat_processus).s_objet_erreur =
! 3581: (*l_element_courant).donnee;
! 3582:
! 3583: l_element_courant = (*l_element_courant).suivant;
! 3584:
! 3585: while(l_element_courant != NULL)
! 3586: {
! 3587: if ((*(*l_element_courant).donnee).type == FCT)
! 3588: {
! 3589: (*s_etat_processus).instruction_courante =
! 3590: (*((struct_fonction *)
! 3591: (*(*l_element_courant).donnee)
! 3592: .objet)).nom_fonction;
! 3593: fonction = (*((struct_fonction *)
! 3594: (*(*l_element_courant).donnee)
! 3595: .objet)).fonction;
! 3596:
! 3597: if (recherche_variable(s_etat_processus,
! 3598: (*s_etat_processus)
! 3599: .instruction_courante) == d_faux)
! 3600: {
! 3601: (*s_etat_processus).erreur_systeme
! 3602: = d_es;
! 3603:
! 3604: /*
! 3605: * Traitement de la pile système par les
! 3606: * différentes instructions.
! 3607: */
! 3608:
! 3609: if (TEST(instruction_if) ||
! 3610: TEST(instruction_iferr) ||
! 3611: TEST(instruction_do) ||
! 3612: TEST(instruction_while) ||
! 3613: TEST(instruction_for) ||
! 3614: TEST(instruction_start) ||
! 3615: TEST(instruction_select) ||
! 3616: TEST(instruction_case) ||
! 3617: TEST(vers_niveau_superieur))
! 3618: {
! 3619: if (TEST(vers_niveau_superieur))
! 3620: {
! 3621: analyse(s_etat_processus,
! 3622: vers_niveau_superieur);
! 3623:
! 3624: if ((*s_etat_processus)
! 3625: .erreur_systeme != d_es)
! 3626: {
! 3627: (*s_etat_processus)
! 3628: .instruction_courante =
! 3629: instruction_courante;
! 3630: return(d_erreur);
! 3631: }
! 3632: }
! 3633: else
! 3634: {
! 3635: empilement_pile_systeme(
! 3636: s_etat_processus);
! 3637:
! 3638: if ((*s_etat_processus)
! 3639: .erreur_systeme != d_es)
! 3640: {
! 3641: if (presence_egalite ==
! 3642: d_vrai)
! 3643: {
! 3644: liberation(
! 3645: s_etat_processus,
! 3646: s_objet_evalue);
! 3647: }
! 3648:
! 3649: (*s_etat_processus)
! 3650: .instruction_courante =
! 3651: instruction_courante;
! 3652: return(d_erreur);
! 3653: }
! 3654: }
! 3655: }
! 3656: else if (TEST(instruction_end) ||
! 3657: TEST(instruction_next) ||
! 3658: TEST(instruction_step) ||
! 3659: TEST(vers_niveau_inferieur))
! 3660: {
! 3661: if (TEST(vers_niveau_inferieur))
! 3662: {
! 3663: analyse(s_etat_processus,
! 3664: vers_niveau_inferieur);
! 3665:
! 3666: if ((*s_etat_processus)
! 3667: .erreur_systeme != d_es)
! 3668: {
! 3669: (*s_etat_processus)
! 3670: .instruction_courante =
! 3671: instruction_courante;
! 3672: return(d_erreur);
! 3673: }
! 3674: }
! 3675: else
! 3676: {
! 3677: depilement_pile_systeme(
! 3678: s_etat_processus);
! 3679:
! 3680: if ((*s_etat_processus)
! 3681: .erreur_systeme != d_es)
! 3682: {
! 3683: if (presence_egalite ==
! 3684: d_vrai)
! 3685: {
! 3686: liberation(
! 3687: s_etat_processus,
! 3688: s_objet_evalue);
! 3689: }
! 3690:
! 3691: (*s_etat_processus)
! 3692: .instruction_courante =
! 3693: instruction_courante;
! 3694: return(d_erreur);
! 3695: }
! 3696: }
! 3697: }
! 3698: }
! 3699: }
! 3700:
! 3701: l_element_courant =
! 3702: (*l_element_courant).suivant;
! 3703: }
! 3704:
! 3705: (*s_etat_processus).mode_execution_programme =
! 3706: registre_mode_execution_programme;
! 3707: (*s_etat_processus).instruction_courante =
! 3708: instruction_courante;
! 3709:
! 3710: if (presence_egalite == d_vrai)
! 3711: {
! 3712: liberation(s_etat_processus, s_objet_evalue);
! 3713: }
! 3714:
! 3715: if ((*s_etat_processus)
! 3716: .var_volatile_processus_pere == 0)
! 3717: {
! 3718: kill((*s_etat_processus)
! 3719: .pid_processus_pere, SIGALRM);
! 3720: }
! 3721: else
! 3722: {
! 3723: (*s_etat_processus).var_volatile_alarme = -1;
! 3724: }
! 3725:
! 3726: (*s_etat_processus).erreur_execution =
! 3727: registre_erreur_execution;
! 3728: (*s_etat_processus).erreur_systeme =
! 3729: registre_erreur_systeme;
! 3730: (*s_etat_processus).exception =
! 3731: registre_exception;
! 3732: return(d_erreur);
! 3733: }
! 3734: }
! 3735:
! 3736: if ((*s_etat_processus).erreur_systeme != d_es)
! 3737: {
! 3738: if (presence_egalite == d_vrai)
! 3739: {
! 3740: liberation(s_etat_processus, s_objet_evalue);
! 3741: }
! 3742:
! 3743: if ((*s_etat_processus).var_volatile_processus_pere
! 3744: == 0)
! 3745: {
! 3746: kill((*s_etat_processus)
! 3747: .pid_processus_pere, SIGALRM);
! 3748: }
! 3749: else
! 3750: {
! 3751: (*s_etat_processus).var_volatile_alarme = -1;
! 3752: }
! 3753:
! 3754: (*s_etat_processus).instruction_courante =
! 3755: instruction_courante;
! 3756: return(d_erreur);
! 3757: }
! 3758: else if (((*s_etat_processus).erreur_execution != d_ex) ||
! 3759: ((*s_etat_processus).exception != d_ep))
! 3760: {
! 3761: if ((*s_etat_processus).arret_si_exception == d_faux)
! 3762: {
! 3763: /*
! 3764: * Reprise sur erreur
! 3765: */
! 3766:
! 3767: if ((message = messages(s_etat_processus)) == NULL)
! 3768: {
! 3769: if (presence_egalite == d_vrai)
! 3770: {
! 3771: liberation(s_etat_processus,
! 3772: s_objet_evalue);
! 3773: }
! 3774:
! 3775: (*s_etat_processus).instruction_courante =
! 3776: instruction_courante;
! 3777: return(d_erreur);
! 3778: }
! 3779:
! 3780: free(message);
! 3781:
! 3782: while((*(*s_etat_processus).l_base_pile_systeme)
! 3783: .clause != 'R')
! 3784: {
! 3785: l_registre_atome = l_element_courant;
! 3786: l_element_courant =
! 3787: (*l_element_courant).suivant;
! 3788:
! 3789: if (l_element_courant == NULL)
! 3790: {
! 3791: /*
! 3792: * La fin de l'expression est atteinte,
! 3793: * le sequenceur reprend la main.
! 3794: */
! 3795:
! 3796: if (presence_egalite == d_vrai)
! 3797: {
! 3798: liberation(s_etat_processus,
! 3799: s_objet_evalue);
! 3800: }
! 3801:
! 3802: (*s_etat_processus)
! 3803: .mode_execution_programme =
! 3804: registre_mode_execution_programme;
! 3805: return(d_absence_erreur);
! 3806: }
! 3807:
! 3808: if ((*(*l_element_courant).donnee).type == FCT)
! 3809: {
! 3810: (*s_etat_processus).instruction_courante =
! 3811: (*((struct_fonction *)
! 3812: (*(*l_element_courant).donnee)
! 3813: .objet)).nom_fonction;
! 3814:
! 3815: if (recherche_variable(s_etat_processus,
! 3816: (*s_etat_processus)
! 3817: .instruction_courante) == d_faux)
! 3818: {
! 3819: (*s_etat_processus).erreur_systeme
! 3820: = d_es;
! 3821: fonction = (*((struct_fonction *)
! 3822: (*(*l_element_courant).donnee)
! 3823: .objet)).fonction;
! 3824:
! 3825: /*
! 3826: * Traitement de la pile système par les
! 3827: * différentes instructions.
! 3828: */
! 3829:
! 3830: if (TEST(instruction_if) ||
! 3831: TEST(instruction_iferr) ||
! 3832: TEST(instruction_do) ||
! 3833: TEST(instruction_while) ||
! 3834: TEST(instruction_for) ||
! 3835: TEST(instruction_start) ||
! 3836: TEST(instruction_select) ||
! 3837: TEST(instruction_case) ||
! 3838: TEST(vers_niveau_superieur))
! 3839: {
! 3840: if (TEST(vers_niveau_superieur))
! 3841: {
! 3842: registre_exception =
! 3843: (*s_etat_processus)
! 3844: .exception;
! 3845: registre_erreur_execution =
! 3846: (*s_etat_processus)
! 3847: .erreur_execution;
! 3848:
! 3849: analyse(s_etat_processus,
! 3850: vers_niveau_superieur);
! 3851:
! 3852: if ((*s_etat_processus)
! 3853: .erreur_systeme != d_es)
! 3854: {
! 3855: (*s_etat_processus)
! 3856: .instruction_courante =
! 3857: instruction_courante;
! 3858: return(d_erreur);
! 3859: }
! 3860:
! 3861: (*s_etat_processus).exception
! 3862: = registre_exception;
! 3863: (*s_etat_processus)
! 3864: .erreur_execution =
! 3865: registre_erreur_execution;
! 3866: }
! 3867: else
! 3868: {
! 3869: empilement_pile_systeme(
! 3870: s_etat_processus);
! 3871:
! 3872: if ((*s_etat_processus)
! 3873: .erreur_systeme != d_es)
! 3874: {
! 3875: if (presence_egalite ==
! 3876: d_vrai)
! 3877: {
! 3878: liberation(
! 3879: s_etat_processus,
! 3880: s_objet_evalue);
! 3881: }
! 3882:
! 3883: (*s_etat_processus)
! 3884: .instruction_courante =
! 3885: instruction_courante;
! 3886: return(d_erreur);
! 3887: }
! 3888: }
! 3889: }
! 3890: else if (TEST(instruction_end) ||
! 3891: TEST(instruction_next) ||
! 3892: TEST(instruction_step) ||
! 3893: TEST(vers_niveau_inferieur))
! 3894: {
! 3895: if (TEST(vers_niveau_inferieur))
! 3896: {
! 3897: registre_exception =
! 3898: (*s_etat_processus)
! 3899: .exception;
! 3900: registre_erreur_execution =
! 3901: (*s_etat_processus)
! 3902: .erreur_execution;
! 3903:
! 3904: analyse(s_etat_processus,
! 3905: vers_niveau_inferieur);
! 3906:
! 3907: if ((*s_etat_processus)
! 3908: .erreur_systeme != d_es)
! 3909: {
! 3910: (*s_etat_processus)
! 3911: .instruction_courante =
! 3912: instruction_courante;
! 3913: return(d_erreur);
! 3914: }
! 3915:
! 3916: (*s_etat_processus).exception
! 3917: = registre_exception;
! 3918: (*s_etat_processus)
! 3919: .erreur_execution =
! 3920: registre_erreur_execution;
! 3921: }
! 3922: else
! 3923: {
! 3924: depilement_pile_systeme(
! 3925: s_etat_processus);
! 3926:
! 3927: if ((*s_etat_processus)
! 3928: .erreur_systeme != d_es)
! 3929: {
! 3930: if (presence_egalite ==
! 3931: d_vrai)
! 3932: {
! 3933: liberation(
! 3934: s_etat_processus,
! 3935: s_objet_evalue);
! 3936: }
! 3937:
! 3938: (*s_etat_processus)
! 3939: .instruction_courante =
! 3940: instruction_courante;
! 3941: return(d_erreur);
! 3942: }
! 3943: }
! 3944: }
! 3945: }
! 3946: }
! 3947: }
! 3948:
! 3949: (*s_etat_processus).instruction_courante =
! 3950: instruction_courante;
! 3951: drapeau_then = d_faux;
! 3952:
! 3953: do
! 3954: {
! 3955: l_registre_atome = l_element_courant;
! 3956:
! 3957: if (l_element_courant == NULL)
! 3958: {
! 3959: /*
! 3960: * La fin de l'expression est atteinte,
! 3961: * le sequenceur reprend la main.
! 3962: */
! 3963:
! 3964: if (presence_egalite == d_vrai)
! 3965: {
! 3966: liberation(s_etat_processus,
! 3967: s_objet_evalue);
! 3968: }
! 3969:
! 3970: (*s_etat_processus)
! 3971: .mode_execution_programme =
! 3972: registre_mode_execution_programme;
! 3973: (*s_etat_processus).instruction_courante =
! 3974: instruction_courante;
! 3975: return(d_absence_erreur);
! 3976: }
! 3977:
! 3978: if ((*(*l_element_courant).donnee).type == FCT)
! 3979: {
! 3980: (*s_etat_processus)
! 3981: .instruction_courante =
! 3982: (*((struct_fonction *)
! 3983: (*(*l_element_courant).donnee)
! 3984: .objet)).nom_fonction;
! 3985: fonction = (*((struct_fonction *)
! 3986: (*(*l_element_courant).donnee)
! 3987: .objet)).fonction;
! 3988: (*s_etat_processus).instruction_courante =
! 3989: instruction_courante;
! 3990:
! 3991: drapeau_then = TEST(instruction_then)
! 3992: ? d_vrai : d_faux;
! 3993: }
! 3994:
! 3995: l_element_courant = (*l_element_courant)
! 3996: .suivant;
! 3997: } while(drapeau_then == d_faux);
! 3998:
! 3999: (*s_etat_processus).expression_courante =
! 4000: l_registre_atome;
! 4001:
! 4002: (*(*s_etat_processus).l_base_pile_systeme)
! 4003: .clause = 'X';
! 4004: instruction_then(s_etat_processus);
! 4005:
! 4006: (*s_etat_processus).exception = d_ep;
! 4007: (*s_etat_processus).erreur_execution = d_ex;
! 4008: }
! 4009: else if ((*s_etat_processus).mode_evaluation_expression
! 4010: == 'Y')
! 4011: {
! 4012: /*
! 4013: * Reprise sur erreur
! 4014: */
! 4015:
! 4016: while(l_element_courant != NULL)
! 4017: {
! 4018: if ((*(*l_element_courant).donnee).type == FCT)
! 4019: {
! 4020: (*s_etat_processus).instruction_courante =
! 4021: (*((struct_fonction *)
! 4022: (*(*l_element_courant).donnee)
! 4023: .objet)).nom_fonction;
! 4024: fonction = (*((struct_fonction *)
! 4025: (*(*l_element_courant).donnee)
! 4026: .objet)).fonction;
! 4027:
! 4028: if (recherche_variable(s_etat_processus,
! 4029: (*s_etat_processus)
! 4030: .instruction_courante) == d_faux)
! 4031: {
! 4032: (*s_etat_processus).erreur_systeme
! 4033: = d_es;
! 4034:
! 4035: /*
! 4036: * Traitement de la pile système par les
! 4037: * différentes instructions.
! 4038: */
! 4039:
! 4040: if (TEST(instruction_if) ||
! 4041: TEST(instruction_iferr) ||
! 4042: TEST(instruction_do) ||
! 4043: TEST(instruction_while) ||
! 4044: TEST(instruction_for) ||
! 4045: TEST(instruction_start) ||
! 4046: TEST(instruction_select) ||
! 4047: TEST(instruction_case) ||
! 4048: TEST(vers_niveau_superieur))
! 4049: {
! 4050: if (TEST(vers_niveau_superieur))
! 4051: {
! 4052: analyse(s_etat_processus,
! 4053: vers_niveau_superieur);
! 4054:
! 4055: if ((*s_etat_processus)
! 4056: .erreur_systeme != d_es)
! 4057: {
! 4058: (*s_etat_processus)
! 4059: .instruction_courante =
! 4060: instruction_courante;
! 4061: return(d_erreur);
! 4062: }
! 4063: }
! 4064: else
! 4065: {
! 4066: empilement_pile_systeme(
! 4067: s_etat_processus);
! 4068:
! 4069: if ((*s_etat_processus)
! 4070: .erreur_systeme != d_es)
! 4071: {
! 4072: if (presence_egalite ==
! 4073: d_vrai)
! 4074: {
! 4075: liberation(
! 4076: s_etat_processus,
! 4077: s_objet_evalue);
! 4078: }
! 4079:
! 4080: (*s_etat_processus)
! 4081: .instruction_courante =
! 4082: instruction_courante;
! 4083: return(d_erreur);
! 4084: }
! 4085: }
! 4086: }
! 4087: else if (TEST(instruction_end) ||
! 4088: TEST(instruction_next) ||
! 4089: TEST(instruction_step) ||
! 4090: TEST(vers_niveau_inferieur))
! 4091: {
! 4092: if (TEST(vers_niveau_inferieur))
! 4093: {
! 4094: analyse(s_etat_processus,
! 4095: vers_niveau_inferieur);
! 4096:
! 4097: if ((*s_etat_processus)
! 4098: .erreur_systeme != d_es)
! 4099: {
! 4100: (*s_etat_processus)
! 4101: .instruction_courante =
! 4102: instruction_courante;
! 4103: return(d_erreur);
! 4104: }
! 4105: }
! 4106: else
! 4107: {
! 4108: depilement_pile_systeme(
! 4109: s_etat_processus);
! 4110:
! 4111: if ((*s_etat_processus)
! 4112: .erreur_systeme != d_es)
! 4113: {
! 4114: if (presence_egalite ==
! 4115: d_vrai)
! 4116: {
! 4117: liberation(
! 4118: s_etat_processus,
! 4119: s_objet_evalue);
! 4120: }
! 4121:
! 4122: (*s_etat_processus)
! 4123: .instruction_courante =
! 4124: instruction_courante;
! 4125: return(d_erreur);
! 4126: }
! 4127: }
! 4128: }
! 4129: }
! 4130: }
! 4131:
! 4132: l_element_courant =
! 4133: (*l_element_courant).suivant;
! 4134: }
! 4135:
! 4136: (*s_etat_processus).mode_execution_programme =
! 4137: registre_mode_execution_programme;
! 4138: (*s_etat_processus).instruction_courante =
! 4139: instruction_courante;
! 4140:
! 4141: (*s_etat_processus).exception = d_ep;
! 4142: (*s_etat_processus).erreur_execution = d_ex;
! 4143:
! 4144: erreur_evaluation = d_erreur;
! 4145:
! 4146: (*s_etat_processus).expression_courante =
! 4147: registre_expression_courante;
! 4148: }
! 4149: else
! 4150: {
! 4151: // On ne détruit pas les variables pour les inclure
! 4152: // dans le fichier rpl-core.
! 4153:
! 4154: (*s_etat_processus).gel_liste_variables = d_vrai;
! 4155:
! 4156: registre_erreur_execution =
! 4157: (*s_etat_processus).erreur_execution;
! 4158: registre_exception =
! 4159: (*s_etat_processus).exception;
! 4160: registre_erreur_systeme =
! 4161: (*s_etat_processus).erreur_systeme;
! 4162:
! 4163: (*s_etat_processus).s_objet_errone = s_objet;
! 4164: (*s_etat_processus).s_objet_erreur =
! 4165: (*l_element_courant).donnee;
! 4166:
! 4167: l_element_courant = (*l_element_courant).suivant;
! 4168:
! 4169: while(l_element_courant != NULL)
! 4170: {
! 4171: if ((*(*l_element_courant).donnee).type == FCT)
! 4172: {
! 4173: (*s_etat_processus).instruction_courante =
! 4174: (*((struct_fonction *)
! 4175: (*(*l_element_courant).donnee)
! 4176: .objet)).nom_fonction;
! 4177: fonction = (*((struct_fonction *)
! 4178: (*(*l_element_courant).donnee)
! 4179: .objet)).fonction;
! 4180:
! 4181: if (recherche_variable(s_etat_processus,
! 4182: (*s_etat_processus)
! 4183: .instruction_courante) == d_faux)
! 4184: {
! 4185: (*s_etat_processus).erreur_systeme
! 4186: = d_es;
! 4187:
! 4188: /*
! 4189: * Traitement de la pile système par les
! 4190: * différentes instructions.
! 4191: */
! 4192:
! 4193: if (TEST(instruction_if) ||
! 4194: TEST(instruction_iferr) ||
! 4195: TEST(instruction_do) ||
! 4196: TEST(instruction_while) ||
! 4197: TEST(instruction_for) ||
! 4198: TEST(instruction_start) ||
! 4199: TEST(instruction_select) ||
! 4200: TEST(instruction_case) ||
! 4201: TEST(vers_niveau_superieur))
! 4202: {
! 4203: if (TEST(vers_niveau_superieur))
! 4204: {
! 4205: analyse(s_etat_processus,
! 4206: vers_niveau_superieur);
! 4207:
! 4208: if ((*s_etat_processus)
! 4209: .erreur_systeme != d_es)
! 4210: {
! 4211: (*s_etat_processus)
! 4212: .instruction_courante =
! 4213: instruction_courante;
! 4214: return(d_erreur);
! 4215: }
! 4216: }
! 4217: else
! 4218: {
! 4219: empilement_pile_systeme(
! 4220: s_etat_processus);
! 4221:
! 4222: if ((*s_etat_processus)
! 4223: .erreur_systeme != d_es)
! 4224: {
! 4225: if (presence_egalite ==
! 4226: d_vrai)
! 4227: {
! 4228: liberation(
! 4229: s_etat_processus,
! 4230: s_objet_evalue);
! 4231: }
! 4232:
! 4233: (*s_etat_processus)
! 4234: .instruction_courante =
! 4235: instruction_courante;
! 4236: return(d_erreur);
! 4237: }
! 4238: }
! 4239: }
! 4240: else if (TEST(instruction_end) ||
! 4241: TEST(instruction_next) ||
! 4242: TEST(instruction_step) ||
! 4243: TEST(vers_niveau_inferieur))
! 4244: {
! 4245: if (TEST(vers_niveau_inferieur))
! 4246: {
! 4247: analyse(s_etat_processus,
! 4248: vers_niveau_inferieur);
! 4249:
! 4250: if ((*s_etat_processus)
! 4251: .erreur_systeme != d_es)
! 4252: {
! 4253: (*s_etat_processus)
! 4254: .instruction_courante =
! 4255: instruction_courante;
! 4256: return(d_erreur);
! 4257: }
! 4258: }
! 4259: else
! 4260: {
! 4261: depilement_pile_systeme(
! 4262: s_etat_processus);
! 4263:
! 4264: if ((*s_etat_processus)
! 4265: .erreur_systeme != d_es)
! 4266: {
! 4267: if (presence_egalite ==
! 4268: d_vrai)
! 4269: {
! 4270: liberation(
! 4271: s_etat_processus,
! 4272: s_objet_evalue);
! 4273: }
! 4274:
! 4275: (*s_etat_processus)
! 4276: .instruction_courante =
! 4277: instruction_courante;
! 4278: return(d_erreur);
! 4279: }
! 4280: }
! 4281: }
! 4282: }
! 4283: }
! 4284:
! 4285: l_element_courant =
! 4286: (*l_element_courant).suivant;
! 4287: }
! 4288:
! 4289: (*s_etat_processus).mode_execution_programme =
! 4290: registre_mode_execution_programme;
! 4291: (*s_etat_processus).instruction_courante =
! 4292: instruction_courante;
! 4293:
! 4294: if (presence_egalite == d_vrai)
! 4295: {
! 4296: liberation(s_etat_processus, s_objet_evalue);
! 4297: }
! 4298:
! 4299: if ((*s_etat_processus)
! 4300: .var_volatile_processus_pere == 0)
! 4301: {
! 4302: kill((*s_etat_processus)
! 4303: .pid_processus_pere, SIGALRM);
! 4304: }
! 4305: else
! 4306: {
! 4307: (*s_etat_processus).var_volatile_alarme = -1;
! 4308: }
! 4309:
! 4310: (*s_etat_processus).erreur_execution =
! 4311: registre_erreur_execution;
! 4312: (*s_etat_processus).erreur_systeme =
! 4313: registre_erreur_systeme;
! 4314: (*s_etat_processus).exception =
! 4315: registre_exception;
! 4316: return(d_erreur);
! 4317: }
! 4318: }
1.1 bertrand 4319: }
4320: else if ((*s_etat_processus).constante_symbolique == 'N')
4321: {
4322: if ((s_objet_elementaire = copie_objet(s_etat_processus,
4323: (*l_element_courant).donnee, 'P')) == NULL)
4324: {
4325: if (presence_egalite == d_vrai)
4326: {
4327: liberation(s_etat_processus, s_objet_evalue);
4328: }
4329:
4330: (*s_etat_processus).erreur_systeme =
4331: d_es_allocation_memoire;
4332: (*s_etat_processus).instruction_courante =
4333: instruction_courante;
4334: return(d_erreur);
4335: }
4336:
4337: presence_fonction = d_faux;
4338: presence_variable_partagee = d_faux;
4339:
4340: if (recherche_variable(s_etat_processus, (*((struct_nom *)
4341: (*s_objet_elementaire).objet)).nom) == d_faux)
4342: {
4343: (*s_etat_processus).erreur_systeme = d_es;
4344: presence_variable = d_faux;
4345: }
4346: else
4347: {
4348: if ((*s_etat_processus).traitement_symbolique == 'N')
4349: {
4350: if ((*s_etat_processus).s_liste_variables
4351: [(*s_etat_processus)
4352: .position_variable_courante].objet == NULL)
4353: {
4354: // Variable partagée
4355:
4356: if (pthread_mutex_lock(&((*(*s_etat_processus)
4357: .s_liste_variables_partagees).mutex))
4358: != 0)
4359: {
4360: (*s_etat_processus).erreur_systeme =
4361: d_es_processus;
4362: return(d_erreur);
4363: }
4364:
4365: presence_variable_partagee = d_faux;
4366:
4367: if (recherche_variable_partagee(
4368: s_etat_processus,
4369: ((*s_etat_processus).s_liste_variables
4370: [(*s_etat_processus)
4371: .position_variable_courante]).nom,
4372: ((*s_etat_processus).s_liste_variables
4373: [(*s_etat_processus)
4374: .position_variable_courante])
4375: .variable_partagee, 'E') == d_vrai)
4376: {
4377: presence_variable = d_vrai;
4378: presence_variable_partagee = d_vrai;
4379:
4380: if ((*((*(*s_etat_processus)
4381: .s_liste_variables_partagees).table
4382: [(*(*s_etat_processus)
4383: .s_liste_variables_partagees)
4384: .position_variable].objet)).type
4385: == ADR)
4386: {
4387: presence_fonction = d_vrai;
4388: }
4389:
4390: if ((type_evaluation == 'N') ||
4391: ((*((struct_nom *)
4392: (*(*l_element_courant).donnee)
4393: .objet)).symbole == d_faux))
4394: {
4395: if ((s_copie_variable_partagee =
4396: copie_objet(s_etat_processus,
4397: (*(*s_etat_processus)
4398: .s_liste_variables_partagees)
4399: .table[(*(*s_etat_processus)
4400: .s_liste_variables_partagees)
4401: .position_variable].objet, 'P'))
4402: == NULL)
4403: {
4404: if (pthread_mutex_unlock(
4405: &((*(*s_etat_processus)
4406: .s_liste_variables_partagees
4407: ).mutex)) != 0)
4408: {
4409: (*s_etat_processus)
4410: .erreur_systeme =
4411: d_es_processus;
4412: return(d_erreur);
4413: }
4414: }
4415: }
4416: else
4417: {
4418: s_copie_variable_partagee = NULL;
4419: }
4420:
4421: if (pthread_mutex_unlock(
4422: &((*(*s_etat_processus)
4423: .s_liste_variables_partagees)
4424: .mutex)) != 0)
4425: {
4426: (*s_etat_processus).erreur_systeme =
4427: d_es_processus;
4428: return(d_erreur);
4429: }
4430: }
4431: else
4432: {
4433: (*s_etat_processus).erreur_systeme = d_es;
4434: presence_variable = d_faux;
4435: presence_variable_partagee = d_faux;
4436:
4437: if (pthread_mutex_unlock(
4438: &((*(*s_etat_processus)
4439: .s_liste_variables_partagees)
4440: .mutex)) != 0)
4441: {
4442: (*s_etat_processus).erreur_systeme =
4443: d_es_processus;
4444: return(d_erreur);
4445: }
4446: }
4447: }
4448: else
4449: {
4450: presence_variable = d_vrai;
4451:
4452: if ((*((*s_etat_processus)
4453: .s_liste_variables
4454: [(*s_etat_processus)
4455: .position_variable_courante]
4456: .objet)).type == ADR)
4457: {
4458: presence_fonction = d_vrai;
4459: }
4460: }
4461: }
4462: else
4463: {
4464: presence_variable = d_faux;
4465: }
4466: }
4467:
4468: liberation(s_etat_processus, s_objet_elementaire);
4469:
4470: if (presence_fonction == d_vrai)
4471: {
4472: autorisation_empilement_programme = (*s_etat_processus)
4473: .autorisation_empilement_programme;
4474: registre_position_courante = (*s_etat_processus)
4475: .position_courante;
4476:
4477: empilement_pile_systeme(s_etat_processus);
4478:
4479: if ((*s_etat_processus).erreur_systeme != d_es)
4480: {
4481: if (presence_variable_partagee == d_vrai)
4482: {
4483: liberation(s_etat_processus,
4484: s_copie_variable_partagee);
4485: }
4486:
4487: if (presence_egalite == d_vrai)
4488: {
4489: liberation(s_etat_processus, s_objet_evalue);
4490: }
4491:
4492: (*s_etat_processus).instruction_courante =
4493: instruction_courante;
4494: return(d_erreur);
4495: }
4496:
4497: (*(*s_etat_processus).l_base_pile_systeme)
4498: .retour_definition = 'Y';
4499: (*(*s_etat_processus).l_base_pile_systeme)
4500: .origine_routine_evaluation = 'Y';
4501:
4502: (*s_etat_processus).mode_execution_programme = 'Y';
4503: (*s_etat_processus).autorisation_empilement_programme
4504: = 'N';
4505:
4506: (*(*s_etat_processus).l_base_pile_systeme)
4507: .niveau_courant = (*s_etat_processus)
4508: .niveau_courant;
4509:
4510: if (presence_variable_partagee == d_faux)
4511: {
4512: (*s_etat_processus).position_courante =
4513: (*((unsigned long *)
4514: ((*((*s_etat_processus).s_liste_variables
4515: [(*s_etat_processus)
4516: .position_variable_courante]
4517: .objet)).objet)));
4518: }
4519: else
4520: {
4521: (*s_etat_processus).position_courante =
4522: (*((unsigned long *)
4523: (*s_copie_variable_partagee).objet));
4524: liberation(s_etat_processus,
4525: s_copie_variable_partagee);
4526: }
4527:
4528: if ((*s_etat_processus).profilage == d_vrai)
4529: {
4530: profilage(s_etat_processus,
4531: (*s_etat_processus).s_liste_variables
4532: [(*s_etat_processus)
4533: .position_variable_courante].nom);
4534:
4535: if ((*s_etat_processus).erreur_systeme != d_es)
4536: {
4537: return(d_erreur);
4538: }
4539: }
4540:
4541: if (sequenceur(s_etat_processus) == d_erreur)
4542: {
4543: if (presence_egalite == d_vrai)
4544: {
4545: liberation(s_etat_processus, s_objet_evalue);
4546: }
4547:
4548: (*s_etat_processus).instruction_courante =
4549: instruction_courante;
4550: (*s_etat_processus).mode_execution_programme =
4551: registre_mode_execution_programme;
4552: return(d_erreur);
4553: }
4554:
4555: (*s_etat_processus).instruction_courante =
4556: instruction_courante;
4557: (*s_etat_processus).mode_execution_programme = 'N';
4558:
4559: depilement_pile_systeme(s_etat_processus);
4560:
4561: if ((*s_etat_processus).erreur_systeme != d_es)
4562: {
4563: if (presence_egalite == d_vrai)
4564: {
4565: liberation(s_etat_processus, s_objet_evalue);
4566: }
4567:
4568: return(d_erreur);
4569: }
4570:
4571: (*s_etat_processus).retour_routine_evaluation = 'N';
4572: (*s_etat_processus).position_courante =
4573: registre_position_courante;
4574: (*s_etat_processus).autorisation_empilement_programme =
4575: autorisation_empilement_programme;
4576: }
4577: else if (((type_evaluation == 'N') || ((*((struct_nom *)
4578: (*(*l_element_courant).donnee).objet)).symbole ==
4579: d_faux)) && (presence_variable == d_vrai))
4580: {
4581: if (type_evaluation == 'I')
4582: {
4583: if (presence_variable_partagee == d_faux)
4584: {
4585: if ((s_sous_objet =
4586: copie_objet(s_etat_processus,
4587: (*s_etat_processus)
4588: .s_liste_variables[(*s_etat_processus)
4589: .position_variable_courante].objet,
4590: 'P')) == NULL)
4591: {
4592: if (presence_variable_partagee == d_vrai)
4593: {
4594: liberation(s_etat_processus,
4595: s_copie_variable_partagee);
4596: }
4597:
4598: if (presence_egalite == d_vrai)
4599: {
4600: liberation(s_etat_processus,
4601: s_objet_evalue);
4602: }
4603:
4604: (*s_etat_processus).erreur_systeme =
4605: d_es_allocation_memoire;
4606: (*s_etat_processus).instruction_courante =
4607: instruction_courante;
4608: return(d_erreur);
4609: }
4610:
4611: if (empilement(s_etat_processus,
4612: &((*s_etat_processus).l_base_pile),
4613: s_sous_objet) == d_erreur)
4614: {
4615: if (presence_variable_partagee == d_vrai)
4616: {
4617: liberation(s_etat_processus,
4618: s_copie_variable_partagee);
4619: }
4620:
4621: if (presence_egalite == d_vrai)
4622: {
4623: liberation(s_etat_processus,
4624: s_objet_evalue);
4625: }
4626:
4627: return(d_erreur);
4628: }
4629: }
4630: else
4631: {
4632: if (empilement(s_etat_processus,
4633: &((*s_etat_processus).l_base_pile),
4634: s_copie_variable_partagee) == d_erreur)
4635: {
4636: if (presence_variable_partagee == d_vrai)
4637: {
4638: liberation(s_etat_processus,
4639: s_copie_variable_partagee);
4640: }
4641:
4642: if (presence_egalite == d_vrai)
4643: {
4644: liberation(s_etat_processus,
4645: s_objet_evalue);
4646: }
4647:
4648: return(d_erreur);
4649: }
4650: }
4651: }
4652: else
4653: {
4654: registre_evaluation_expression_compilee =
4655: (*s_etat_processus)
4656: .evaluation_expression_compilee;
4657:
4658: if (((*s_etat_processus).s_liste_variables
4659: [(*s_etat_processus)
4660: .position_variable_courante].origine == 'E')
4661: && ((*s_etat_processus).s_liste_variables
4662: [(*s_etat_processus)
4663: .position_variable_courante].niveau == 0))
4664: {
4665: (*s_etat_processus)
4666: .evaluation_expression_compilee = 'Y';
4667: }
4668: else
4669: {
4670: (*s_etat_processus)
4671: .evaluation_expression_compilee = 'N';
4672: }
4673:
4674: if (presence_variable_partagee == d_faux)
4675: {
4676: if ((*s_etat_processus).profilage == d_vrai)
4677: {
4678: profilage(s_etat_processus,
4679: (*s_etat_processus)
4680: .s_liste_variables
4681: [(*s_etat_processus)
4682: .position_variable_courante].nom);
4683:
4684: if ((*s_etat_processus).erreur_systeme
4685: != d_es)
4686: {
4687: return(d_erreur);
4688: }
4689: }
4690:
4691: registre_niveau_courant = (*(*s_etat_processus)
4692: .l_base_pile_systeme).niveau_courant;
4693: registre_retour_definition =
4694: (*(*s_etat_processus)
4695: .l_base_pile_systeme).retour_definition;
4696:
4697: (*(*s_etat_processus).l_base_pile_systeme)
4698: .retour_definition = 'Y';
4699: (*(*s_etat_processus).l_base_pile_systeme)
4700: .niveau_courant = (*s_etat_processus)
4701: .niveau_courant;
4702: empilement_pile_systeme(s_etat_processus);
4703:
4704: if (evaluation(s_etat_processus,
4705: (*s_etat_processus)
4706: .s_liste_variables[(*s_etat_processus)
4707: .position_variable_courante].objet,
4708: type_evaluation) == d_erreur)
4709: {
4710: depilement_pile_systeme(s_etat_processus);
4711:
4712: (*(*s_etat_processus).l_base_pile_systeme)
4713: .niveau_courant =
4714: (*(*s_etat_processus).l_base_pile_systeme)
4715: .retour_definition =
4716: registre_retour_definition;
4717:
4718: if ((*s_etat_processus).profilage == d_vrai)
4719: {
4720: profilage(s_etat_processus, NULL);
4721: }
4722:
4723: (*s_etat_processus)
4724: .evaluation_expression_compilee =
4725: registre_evaluation_expression_compilee;
4726:
4727: if (presence_egalite == d_vrai)
4728: {
4729: liberation(s_etat_processus,
4730: s_objet_evalue);
4731: }
4732:
4733: (*s_etat_processus).instruction_courante =
4734: instruction_courante;
4735: (*s_etat_processus).mode_execution_programme
4736: = registre_mode_execution_programme;
4737: return(d_erreur);
4738: }
4739:
4740: depilement_pile_systeme(s_etat_processus);
4741:
4742: (*(*s_etat_processus).l_base_pile_systeme)
4743: .niveau_courant =
4744: (*(*s_etat_processus).l_base_pile_systeme)
4745: .retour_definition =
4746: registre_retour_definition;
4747: }
4748: else
4749: {
4750: if ((*s_etat_processus).profilage == d_vrai)
4751: {
4752: profilage(s_etat_processus,
4753: (*s_etat_processus)
4754: .s_liste_variables
4755: [(*s_etat_processus)
4756: .position_variable_courante].nom);
4757:
4758: if ((*s_etat_processus).erreur_systeme
4759: != d_es)
4760: {
4761: return(d_erreur);
4762: }
4763: }
4764:
4765: empilement_pile_systeme(s_etat_processus);
4766: (*(*s_etat_processus).l_base_pile_systeme)
4767: .retour_definition = 'Y';
4768: (*(*s_etat_processus).l_base_pile_systeme)
4769: .niveau_courant = (*s_etat_processus)
4770: .niveau_courant;
4771: empilement_pile_systeme(s_etat_processus);
4772:
4773: if (evaluation(s_etat_processus,
4774: s_copie_variable_partagee,
4775: type_evaluation) == d_erreur)
4776: {
4777: depilement_pile_systeme(s_etat_processus);
4778: depilement_pile_systeme(s_etat_processus);
4779:
4780: liberation(s_etat_processus,
4781: s_copie_variable_partagee);
4782:
4783: if ((*s_etat_processus).profilage == d_vrai)
4784: {
4785: profilage(s_etat_processus, NULL);
4786: }
4787:
4788: (*s_etat_processus)
4789: .evaluation_expression_compilee =
4790: registre_evaluation_expression_compilee;
4791:
4792: if (presence_egalite == d_vrai)
4793: {
4794: liberation(s_etat_processus,
4795: s_objet_evalue);
4796: }
4797:
4798: (*s_etat_processus).instruction_courante =
4799: instruction_courante;
4800: (*s_etat_processus).mode_execution_programme
4801: = registre_mode_execution_programme;
4802: return(d_erreur);
4803: }
4804:
4805: depilement_pile_systeme(s_etat_processus);
4806: depilement_pile_systeme(s_etat_processus);
4807:
4808: liberation(s_etat_processus,
4809: s_copie_variable_partagee);
4810: }
4811:
4812: if ((*s_etat_processus).profilage == d_vrai)
4813: {
4814: profilage(s_etat_processus, NULL);
4815: }
4816:
4817: (*s_etat_processus)
4818: .evaluation_expression_compilee =
4819: registre_evaluation_expression_compilee;
4820: }
4821: }
4822: else
4823: {
4824: if (presence_variable_partagee == d_vrai)
4825: {
4826: liberation(s_etat_processus,
4827: s_copie_variable_partagee);
4828: }
4829:
4830: if ((s_objet_elementaire =
4831: copie_objet(s_etat_processus,
4832: (*l_element_courant).donnee, 'P')) == NULL)
4833: {
4834: if (presence_egalite == d_vrai)
4835: {
4836: liberation(s_etat_processus, s_objet_evalue);
4837: }
4838:
4839: (*s_etat_processus).erreur_systeme =
4840: d_es_allocation_memoire;
4841: (*s_etat_processus).instruction_courante =
4842: instruction_courante;
4843: return(d_erreur);
4844: }
4845:
4846: /*
4847: * Vérification du drapeau symbole pour
4848: * savoir si l'on met dans la pile le nom
4849: * ou le contenu de la variable.
4850: */
4851:
4852: if (((*((struct_nom *) (*s_objet_elementaire).objet))
4853: .symbole == d_faux) && ((*s_etat_processus)
4854: .traitement_symbolique == 'N'))
4855: {
4856: if (recherche_variable(s_etat_processus,
4857: (*((struct_nom *) (*s_objet_elementaire)
4858: .objet)).nom) == d_vrai)
4859: {
4860: if ((*s_etat_processus).s_liste_variables
4861: [(*s_etat_processus)
4862: .position_variable_courante].objet
4863: == NULL)
4864: {
4865: // Variable partagée
4866:
4867: if (pthread_mutex_lock(
4868: &((*(*s_etat_processus)
4869: .s_liste_variables_partagees)
4870: .mutex)) != 0)
4871: {
4872: (*s_etat_processus).erreur_systeme =
4873: d_es_processus;
4874: return(d_erreur);
4875: }
4876:
4877: if (recherche_variable_partagee(
4878: s_etat_processus,
4879: ((*s_etat_processus)
4880: .s_liste_variables
4881: [(*s_etat_processus)
4882: .position_variable_courante]).nom,
4883: ((*s_etat_processus)
4884: .s_liste_variables
4885: [(*s_etat_processus)
4886: .position_variable_courante])
4887: .variable_partagee, 'E') == d_vrai)
4888: {
4889: liberation(s_etat_processus,
4890: s_objet_elementaire);
4891:
4892: if ((s_objet_elementaire =
4893: copie_objet(s_etat_processus,
4894: (*(*s_etat_processus)
4895: .s_liste_variables_partagees)
4896: .table[(*(*s_etat_processus)
4897: .s_liste_variables_partagees)
4898: .position_variable].objet,
4899: 'P')) == NULL)
4900: {
4901: if (pthread_mutex_unlock(
4902: &((*(*s_etat_processus)
4903: .s_liste_variables_partagees
4904: ).mutex)) != 0)
4905: {
4906: (*s_etat_processus)
4907: .erreur_systeme =
4908: d_es_processus;
4909: return(d_erreur);
4910: }
4911:
4912: if (presence_egalite == d_vrai)
4913: {
4914: liberation(s_etat_processus,
4915: s_objet_evalue);
4916: }
4917:
4918: (*s_etat_processus).erreur_systeme =
4919: d_es_allocation_memoire;
4920: (*s_etat_processus)
4921: .instruction_courante =
4922: instruction_courante;
4923: return(d_erreur);
4924: }
4925: }
4926:
4927: if (pthread_mutex_unlock(
4928: &((*(*s_etat_processus)
4929: .s_liste_variables_partagees)
4930: .mutex)) != 0)
4931: {
4932: (*s_etat_processus).erreur_systeme =
4933: d_es_processus;
4934: return(d_erreur);
4935: }
4936: }
4937: else
4938: {
4939: // Variable privée
4940:
4941: liberation(s_etat_processus,
4942: s_objet_elementaire);
4943:
4944: if ((s_objet_elementaire =
4945: copie_objet(s_etat_processus,
4946: (*s_etat_processus)
4947: .s_liste_variables
4948: [(*s_etat_processus)
4949: .position_variable_courante].objet,
4950: 'P')) == NULL)
4951: {
4952: if (presence_egalite == d_vrai)
4953: {
4954: liberation(s_etat_processus,
4955: s_objet_evalue);
4956: }
4957:
4958: (*s_etat_processus).erreur_systeme =
4959: d_es_allocation_memoire;
4960: (*s_etat_processus)
4961: .instruction_courante =
4962: instruction_courante;
4963: return(d_erreur);
4964: }
4965: }
4966: }
4967: else
4968: {
4969: (*s_etat_processus).erreur_systeme = d_es;
4970:
4971: (*((struct_nom *) (*s_objet_elementaire)
4972: .objet)).symbole = d_vrai;
4973: }
4974: }
4975:
4976: if (empilement(s_etat_processus, &((*s_etat_processus)
4977: .l_base_pile), s_objet_elementaire) == d_erreur)
4978: {
4979: if (presence_egalite == d_vrai)
4980: {
4981: liberation(s_etat_processus, s_objet_evalue);
4982: }
4983:
4984: (*s_etat_processus).instruction_courante =
4985: instruction_courante;
4986: return(d_erreur);
4987: }
4988:
4989: if ((*s_etat_processus).erreur_execution ==
4990: d_ex_variable_non_definie)
4991: {
4992: (*s_etat_processus).erreur_execution = d_ex;
4993: }
4994: }
4995: }
4996: else
4997: {
4998: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
4999: == d_vrai) ? 'E' : 'N';
5000:
5001: if (type_evaluation == 'N')
5002: {
5003: cf(s_etat_processus, 35);
5004: }
5005: else
5006: {
5007: sf(s_etat_processus, 35);
5008: }
5009:
5010: analyse(s_etat_processus, NULL);
5011:
5012: if (registre_type_evaluation == 'E')
5013: {
5014: sf(s_etat_processus, 35);
5015: }
5016: else
5017: {
5018: cf(s_etat_processus, 35);
5019: }
5020:
5021: if (((*s_etat_processus).erreur_systeme != d_es) ||
5022: ((*s_etat_processus).erreur_execution != d_ex) ||
5023: ((*s_etat_processus).exception != d_ep))
5024: {
5025: if (presence_egalite == d_vrai)
5026: {
5027: liberation(s_etat_processus, s_objet_evalue);
5028: }
5029:
5030: (*s_etat_processus).instruction_courante =
5031: instruction_courante;
5032: (*s_etat_processus).mode_execution_programme =
5033: registre_mode_execution_programme;
5034: return(d_erreur);
5035: }
5036: }
5037:
5038: (*s_etat_processus).instruction_courante =
5039: instruction_courante;
5040: (*s_etat_processus).test_instruction = registre_test;
5041: (*s_etat_processus).instruction_valide =
5042: registre_instruction_valide;
5043: }
5044: else
5045: {
5046: if ((s_objet_tampon = copie_objet(s_etat_processus,
5047: (*l_element_courant).donnee, 'P')) == NULL)
5048: {
5049: (*s_etat_processus).erreur_systeme =
5050: d_es_allocation_memoire;
5051: (*s_etat_processus).instruction_courante =
5052: instruction_courante;
5053: return(d_erreur);
5054: }
5055:
5056: if (empilement(s_etat_processus, &((*s_etat_processus)
5057: .l_base_pile), s_objet_tampon) == d_erreur)
5058: {
5059: if (presence_egalite == d_vrai)
5060: {
5061: liberation(s_etat_processus, s_objet_evalue);
5062: }
5063:
5064: (*s_etat_processus).instruction_courante =
5065: instruction_courante;
5066: return(d_erreur);
5067: }
5068: }
5069:
5070: // Traitement de l'instruction EXIT en mode interactif
5071:
5072: if (l_element_courant != NULL)
5073: {
5074: l_element_courant = (*l_element_courant).suivant;
5075: }
5076: else
5077: {
5078: (*s_etat_processus).mode_execution_programme = 'Y';
5079:
5080: if ((*s_etat_processus).niveau_courant == 1)
5081: {
5082: (*s_etat_processus).debug_programme = d_faux;
5083: (*s_etat_processus).execution_pas_suivant = d_vrai;
5084: }
5085: }
5086:
5087: if ((*s_etat_processus).traitement_cycle_exit != 'N')
5088: {
5089: registre_expression_courante =
5090: (*s_etat_processus).expression_courante;
5091: (*s_etat_processus).expression_courante =
5092: l_element_courant;
5093:
5094: switch((*s_etat_processus).traitement_cycle_exit)
5095: {
5096: case 'C' :
5097: {
5098: instruction_cycle(s_etat_processus);
5099: break;
5100: }
5101:
5102: case 'E' :
5103: {
5104: instruction_exit(s_etat_processus);
5105: break;
5106: }
5107: }
5108:
5109: l_element_courant = (*s_etat_processus).expression_courante;
5110: (*s_etat_processus).expression_courante =
5111: registre_expression_courante;
5112: }
5113: }
5114:
5115: if (niveau_initial < (*s_etat_processus).niveau_courant)
5116: {
5117: /*
5118: * Retrait des variables dans le cas où l'évaluation de
5119: * l'expression a été interrompue
5120: */
5121:
5122: (*s_etat_processus).niveau_courant = niveau_initial;
5123:
5124: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5125: {
5126: if ((*s_etat_processus).s_liste_variables[n].niveau
5127: > niveau_initial)
5128: {
5129: m++;
5130: }
5131: }
5132:
5133: registre_variables = (*s_etat_processus).s_liste_variables;
5134: (*s_etat_processus).nombre_variables -= m;
5135:
5136: if (((*s_etat_processus).s_liste_variables = malloc(
5137: (*s_etat_processus).nombre_variables *
5138: sizeof(struct_variable))) == NULL)
5139: {
5140: if (presence_egalite == d_vrai)
5141: {
5142: liberation(s_etat_processus, s_objet_evalue);
5143: }
5144:
5145: (*s_etat_processus).instruction_courante = instruction_courante;
5146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5147: return(d_erreur);
5148: }
5149:
5150: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5151: {
5152: if (registre_variables[n + m].niveau > niveau_initial)
5153: {
5154: free(registre_variables[n + m].nom);
5155: liberation(s_etat_processus,
5156: registre_variables[n + m].objet);
5157: m++;
5158: n--;
5159: }
5160: else
5161: {
5162: (*s_etat_processus).s_liste_variables[n] =
5163: registre_variables[n + m];
5164: }
5165: }
5166:
5167: free(registre_variables);
5168: }
5169:
5170: /*
5171: * Retrait des variables statiques créées dans l'expression
5172: */
5173:
5174: for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
5175: {
5176: if ((*s_etat_processus).s_liste_variables_statiques[n]
5177: .niveau > (*s_etat_processus).niveau_courant)
5178: {
5179: if (retrait_variable_statique(s_etat_processus,
5180: (*s_etat_processus).s_liste_variables_statiques[n].nom,
5181: (*s_etat_processus).s_liste_variables_statiques[n]
5182: .variable_statique) == d_erreur)
5183: {
5184: if (presence_egalite == d_vrai)
5185: {
5186: liberation(s_etat_processus, s_objet_evalue);
5187: }
5188:
5189: (*s_etat_processus).instruction_courante =
5190: instruction_courante;
5191: (*s_etat_processus).mode_execution_programme =
5192: registre_mode_execution_programme;
5193: return(d_erreur);
5194: }
5195: }
5196: }
5197:
5198: /*
5199: * Retrait des variables partagées créées dans l'expression
5200: */
5201:
5202: if (pthread_mutex_lock(&((*(*s_etat_processus)
5203: .s_liste_variables_partagees).mutex)) != 0)
5204: {
5205: (*s_etat_processus).erreur_systeme = d_es_processus;
5206: return(d_erreur);
5207: }
5208:
5209: for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
5210: .nombre_variables; n++)
5211: {
5212: if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
5213: .niveau > (*s_etat_processus).niveau_courant)
5214: {
5215: if (retrait_variable_partagee(s_etat_processus,
5216: (*(*s_etat_processus).s_liste_variables_partagees)
5217: .table[n].nom, (*(*s_etat_processus)
5218: .s_liste_variables_partagees).table[n]
5219: .variable_partagee) == d_erreur)
5220: {
5221: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5222: .s_liste_variables_partagees).mutex)) != 0)
5223: {
5224: (*s_etat_processus).erreur_systeme = d_es_processus;
5225: return(d_erreur);
5226: }
5227:
5228: if (presence_egalite == d_vrai)
5229: {
5230: liberation(s_etat_processus, s_objet_evalue);
5231: }
5232:
5233: (*s_etat_processus).instruction_courante =
5234: instruction_courante;
5235: (*s_etat_processus).mode_execution_programme =
5236: registre_mode_execution_programme;
5237: return(d_erreur);
5238: }
5239: }
5240: }
5241:
5242: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5243: .s_liste_variables_partagees).mutex)) != 0)
5244: {
5245: (*s_etat_processus).erreur_systeme = d_es_processus;
5246: return(d_erreur);
5247: }
5248:
5249: if ((*s_etat_processus).var_volatile_requete_arret != 0)
5250: {
5251: // Restauration de la pile système
5252:
5253: while(pile_systeme_originelle !=
5254: (*s_etat_processus).l_base_pile_systeme)
5255: {
5256: depilement_pile_systeme(s_etat_processus);
5257: }
5258: }
5259:
5260: if (presence_egalite == d_vrai)
5261: {
5262: // Ajout du membre évalué lors de la première passe
5263:
5264: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5265: s_objet_evalue) == d_erreur)
5266: {
5267: (*s_etat_processus).instruction_courante =
5268: instruction_courante;
5269: return(d_erreur);
5270: }
5271:
5272: instruction_swap(s_etat_processus);
5273:
5274: if ((*s_etat_processus).erreur_execution != d_ex)
5275: {
5276: (*s_etat_processus).mode_execution_programme =
5277: registre_mode_execution_programme;
5278: (*s_etat_processus).autorisation_empilement_programme =
5279: autorisation_empilement_programme;
5280: (*s_etat_processus).instruction_courante = instruction_courante;
5281: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5282: registre_retour_definition;
5283:
5284: return(d_erreur);
5285: }
5286:
5287: instruction_egalite(s_etat_processus);
5288:
5289: if ((*s_etat_processus).erreur_execution != d_ex)
5290: {
5291: (*s_etat_processus).mode_execution_programme =
5292: registre_mode_execution_programme;
5293: (*s_etat_processus).autorisation_empilement_programme =
5294: autorisation_empilement_programme;
5295: (*s_etat_processus).instruction_courante = instruction_courante;
5296: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5297: registre_retour_definition;
5298:
5299: return(d_erreur);
5300: }
5301: }
5302:
5303: (*s_etat_processus).autorisation_empilement_programme =
5304: autorisation_empilement_programme;
5305: (*s_etat_processus).instruction_courante = instruction_courante;
5306: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5307: registre_retour_definition;
5308: }
5309: else if ((*s_objet).type == FCT)
5310: {
5311: (*s_etat_processus).instruction_courante =
5312: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
5313:
5314: analyse(s_etat_processus, (*((struct_fonction *)
5315: (*s_objet).objet)).fonction);
5316:
5317: (*s_etat_processus).instruction_courante = instruction_courante;
5318:
5319: if (((*s_etat_processus).erreur_systeme != d_es) ||
5320: ((*s_etat_processus).erreur_execution != d_ex) ||
5321: ((*s_etat_processus).exception != d_ep))
5322: {
5323: (*s_etat_processus).instruction_courante = instruction_courante;
5324: (*s_etat_processus).mode_execution_programme =
5325: registre_mode_execution_programme;
5326: return(d_erreur);
5327: }
5328: }
5329: else
5330: {
5331: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
5332: == NULL)
5333: {
5334: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5335: (*s_etat_processus).instruction_courante = instruction_courante;
5336: return(d_erreur);
5337: }
5338:
5339: if (empilement(s_etat_processus, &((*s_etat_processus)
5340: .l_base_pile), s_objet_tampon) == d_erreur)
5341: {
5342: (*s_etat_processus).instruction_courante = instruction_courante;
5343: return(d_erreur);
5344: }
5345: }
5346:
5347: (*s_etat_processus).mode_execution_programme =
5348: registre_mode_execution_programme;
5349:
5350: return((erreur_evaluation == d_absence_erreur)
5351: ? d_absence_erreur : d_erreur);
5352: }
5353:
5354: // vim: ts=4