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