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