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