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