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