1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.10
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: analyse(s_etat_processus, NULL);
3175:
3176: (*s_etat_processus).test_instruction = registre_test_2;
3177:
3178: if ((*s_etat_processus).erreur_systeme != d_es)
3179: {
3180: if (presence_egalite == d_vrai)
3181: {
3182: liberation(s_etat_processus, s_objet_evalue);
3183: }
3184:
3185: if ((*s_etat_processus).var_volatile_processus_pere
3186: == 0)
3187: {
3188: kill((*s_etat_processus)
3189: .pid_processus_pere, SIGALRM);
3190: }
3191: else
3192: {
3193: (*s_etat_processus).var_volatile_alarme = -1;
3194: }
3195:
3196: (*s_etat_processus).instruction_courante =
3197: instruction_courante;
3198: return(d_erreur);
3199: }
3200: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3201: ((*s_etat_processus).exception != d_ep))
3202: {
3203: if ((*s_etat_processus).arret_si_exception == d_faux)
3204: {
3205: /*
3206: * Reprise sur erreur
3207: */
3208:
3209: if ((message = messages(s_etat_processus)) == NULL)
3210: {
3211: if (presence_egalite == d_vrai)
3212: {
3213: liberation(s_etat_processus,
3214: s_objet_evalue);
3215: }
3216:
3217: (*s_etat_processus).instruction_courante =
3218: instruction_courante;
3219: return(d_erreur);
3220: }
3221:
3222: free(message);
3223:
3224: while((*(*s_etat_processus).l_base_pile_systeme)
3225: .clause != 'R')
3226: {
3227: l_registre_atome = l_element_courant;
3228: l_element_courant =
3229: (*l_element_courant).suivant;
3230:
3231: if (l_element_courant == NULL)
3232: {
3233: /*
3234: * La fin de l'expression est atteinte,
3235: * le sequenceur reprend la main.
3236: */
3237:
3238: if (presence_egalite == d_vrai)
3239: {
3240: liberation(s_etat_processus,
3241: s_objet_evalue);
3242: }
3243:
3244: (*s_etat_processus)
3245: .mode_execution_programme =
3246: registre_mode_execution_programme;
3247: return(d_absence_erreur);
3248: }
3249:
3250: if ((*(*l_element_courant).donnee).type == FCT)
3251: {
3252: (*s_etat_processus).instruction_courante =
3253: (*((struct_fonction *)
3254: (*(*l_element_courant).donnee)
3255: .objet)).nom_fonction;
3256:
3257: if (recherche_variable(s_etat_processus,
3258: (*s_etat_processus)
3259: .instruction_courante) == d_faux)
3260: {
3261: (*s_etat_processus).erreur_systeme
3262: = d_es;
3263: fonction = (*((struct_fonction *)
3264: (*(*l_element_courant).donnee)
3265: .objet)).fonction;
3266:
3267: /*
3268: * Traitement de la pile système par les
3269: * différentes instructions.
3270: */
3271:
3272: if (TEST(instruction_if) ||
3273: TEST(instruction_iferr) ||
3274: TEST(instruction_do) ||
3275: TEST(instruction_while) ||
3276: TEST(instruction_for) ||
3277: TEST(instruction_start) ||
3278: TEST(instruction_select) ||
3279: TEST(instruction_case) ||
3280: TEST(vers_niveau_superieur))
3281: {
3282: if (TEST(vers_niveau_superieur))
3283: {
3284: registre_exception =
3285: (*s_etat_processus)
3286: .exception;
3287: registre_erreur_execution =
3288: (*s_etat_processus)
3289: .erreur_execution;
3290:
3291: analyse(s_etat_processus,
3292: vers_niveau_superieur);
3293:
3294: if ((*s_etat_processus)
3295: .erreur_systeme != d_es)
3296: {
3297: (*s_etat_processus)
3298: .instruction_courante =
3299: instruction_courante;
3300: return(d_erreur);
3301: }
3302:
3303: (*s_etat_processus).exception
3304: = registre_exception;
3305: (*s_etat_processus)
3306: .erreur_execution =
3307: registre_erreur_execution;
3308: }
3309: else
3310: {
3311: empilement_pile_systeme(
3312: s_etat_processus);
3313:
3314: if ((*s_etat_processus)
3315: .erreur_systeme != d_es)
3316: {
3317: if (presence_egalite ==
3318: d_vrai)
3319: {
3320: liberation(
3321: s_etat_processus,
3322: s_objet_evalue);
3323: }
3324:
3325: (*s_etat_processus)
3326: .instruction_courante =
3327: instruction_courante;
3328: return(d_erreur);
3329: }
3330: }
3331: }
3332: else if (TEST(instruction_end) ||
3333: TEST(instruction_next) ||
3334: TEST(instruction_step) ||
3335: TEST(vers_niveau_inferieur))
3336: {
3337: if (TEST(vers_niveau_inferieur))
3338: {
3339: registre_exception =
3340: (*s_etat_processus)
3341: .exception;
3342: registre_erreur_execution =
3343: (*s_etat_processus)
3344: .erreur_execution;
3345:
3346: analyse(s_etat_processus,
3347: vers_niveau_inferieur);
3348:
3349: if ((*s_etat_processus)
3350: .erreur_systeme != d_es)
3351: {
3352: (*s_etat_processus)
3353: .instruction_courante =
3354: instruction_courante;
3355: return(d_erreur);
3356: }
3357:
3358: (*s_etat_processus).exception
3359: = registre_exception;
3360: (*s_etat_processus)
3361: .erreur_execution =
3362: registre_erreur_execution;
3363: }
3364: else
3365: {
3366: depilement_pile_systeme(
3367: s_etat_processus);
3368:
3369: if ((*s_etat_processus)
3370: .erreur_systeme != d_es)
3371: {
3372: if (presence_egalite ==
3373: d_vrai)
3374: {
3375: liberation(
3376: s_etat_processus,
3377: s_objet_evalue);
3378: }
3379:
3380: (*s_etat_processus)
3381: .instruction_courante =
3382: instruction_courante;
3383: return(d_erreur);
3384: }
3385: }
3386: }
3387: }
3388: }
3389: }
3390:
3391: (*s_etat_processus).instruction_courante =
3392: instruction_courante;
3393: drapeau_then = d_faux;
3394:
3395: do
3396: {
3397: l_registre_atome = l_element_courant;
3398:
3399: if (l_element_courant == NULL)
3400: {
3401: /*
3402: * La fin de l'expression est atteinte,
3403: * le sequenceur reprend la main.
3404: */
3405:
3406: if (presence_egalite == d_vrai)
3407: {
3408: liberation(s_etat_processus,
3409: s_objet_evalue);
3410: }
3411:
3412: (*s_etat_processus)
3413: .mode_execution_programme =
3414: registre_mode_execution_programme;
3415: (*s_etat_processus).instruction_courante =
3416: instruction_courante;
3417: return(d_absence_erreur);
3418: }
3419:
3420: if ((*(*l_element_courant).donnee).type == FCT)
3421: {
3422: (*s_etat_processus)
3423: .instruction_courante =
3424: (*((struct_fonction *)
3425: (*(*l_element_courant).donnee)
3426: .objet)).nom_fonction;
3427: fonction = (*((struct_fonction *)
3428: (*(*l_element_courant).donnee)
3429: .objet)).fonction;
3430: (*s_etat_processus).instruction_courante =
3431: instruction_courante;
3432:
3433: drapeau_then = TEST(instruction_then)
3434: ? d_vrai : d_faux;
3435: }
3436:
3437: l_element_courant = (*l_element_courant)
3438: .suivant;
3439: } while(drapeau_then == d_faux);
3440:
3441: (*s_etat_processus).expression_courante =
3442: l_registre_atome;
3443:
3444: (*(*s_etat_processus).l_base_pile_systeme)
3445: .clause = 'X';
3446: instruction_then(s_etat_processus);
3447:
3448: (*s_etat_processus).exception = d_ep;
3449: (*s_etat_processus).erreur_execution = d_ex;
3450: }
3451: else if ((*s_etat_processus).mode_evaluation_expression
3452: == 'Y')
3453: {
3454: /*
3455: * Reprise sur erreur
3456: */
3457:
3458: while(l_element_courant != NULL)
3459: {
3460: if ((*(*l_element_courant).donnee).type == FCT)
3461: {
3462: (*s_etat_processus).instruction_courante =
3463: (*((struct_fonction *)
3464: (*(*l_element_courant).donnee)
3465: .objet)).nom_fonction;
3466: fonction = (*((struct_fonction *)
3467: (*(*l_element_courant).donnee)
3468: .objet)).fonction;
3469:
3470: if (recherche_variable(s_etat_processus,
3471: (*s_etat_processus)
3472: .instruction_courante) == d_faux)
3473: {
3474: (*s_etat_processus).erreur_systeme
3475: = d_es;
3476:
3477: /*
3478: * Traitement de la pile système par les
3479: * différentes instructions.
3480: */
3481:
3482: if (TEST(instruction_if) ||
3483: TEST(instruction_iferr) ||
3484: TEST(instruction_do) ||
3485: TEST(instruction_while) ||
3486: TEST(instruction_for) ||
3487: TEST(instruction_start) ||
3488: TEST(instruction_select) ||
3489: TEST(instruction_case) ||
3490: TEST(vers_niveau_superieur))
3491: {
3492: if (TEST(vers_niveau_superieur))
3493: {
3494: analyse(s_etat_processus,
3495: vers_niveau_superieur);
3496:
3497: if ((*s_etat_processus)
3498: .erreur_systeme != d_es)
3499: {
3500: (*s_etat_processus)
3501: .instruction_courante =
3502: instruction_courante;
3503: return(d_erreur);
3504: }
3505: }
3506: else
3507: {
3508: empilement_pile_systeme(
3509: s_etat_processus);
3510:
3511: if ((*s_etat_processus)
3512: .erreur_systeme != d_es)
3513: {
3514: if (presence_egalite ==
3515: d_vrai)
3516: {
3517: liberation(
3518: s_etat_processus,
3519: s_objet_evalue);
3520: }
3521:
3522: (*s_etat_processus)
3523: .instruction_courante =
3524: instruction_courante;
3525: return(d_erreur);
3526: }
3527: }
3528: }
3529: else if (TEST(instruction_end) ||
3530: TEST(instruction_next) ||
3531: TEST(instruction_step) ||
3532: TEST(vers_niveau_inferieur))
3533: {
3534: if (TEST(vers_niveau_inferieur))
3535: {
3536: analyse(s_etat_processus,
3537: vers_niveau_inferieur);
3538:
3539: if ((*s_etat_processus)
3540: .erreur_systeme != d_es)
3541: {
3542: (*s_etat_processus)
3543: .instruction_courante =
3544: instruction_courante;
3545: return(d_erreur);
3546: }
3547: }
3548: else
3549: {
3550: depilement_pile_systeme(
3551: s_etat_processus);
3552:
3553: if ((*s_etat_processus)
3554: .erreur_systeme != d_es)
3555: {
3556: if (presence_egalite ==
3557: d_vrai)
3558: {
3559: liberation(
3560: s_etat_processus,
3561: s_objet_evalue);
3562: }
3563:
3564: (*s_etat_processus)
3565: .instruction_courante =
3566: instruction_courante;
3567: return(d_erreur);
3568: }
3569: }
3570: }
3571: }
3572: }
3573:
3574: l_element_courant =
3575: (*l_element_courant).suivant;
3576: }
3577:
3578: (*s_etat_processus).mode_execution_programme =
3579: registre_mode_execution_programme;
3580: (*s_etat_processus).instruction_courante =
3581: instruction_courante;
3582:
3583: (*s_etat_processus).exception = d_ep;
3584: (*s_etat_processus).erreur_execution = d_ex;
3585:
3586: erreur_evaluation = d_erreur;
3587: }
3588: else
3589: {
3590: // On ne détruit pas les variables pour les inclure
3591: // dans le fichier rpl-core.
3592:
3593: (*s_etat_processus).gel_liste_variables = d_vrai;
3594:
3595: registre_erreur_execution =
3596: (*s_etat_processus).erreur_execution;
3597: registre_exception =
3598: (*s_etat_processus).exception;
3599: registre_erreur_systeme =
3600: (*s_etat_processus).erreur_systeme;
3601:
3602: (*s_etat_processus).s_objet_errone = s_objet;
3603: (*s_etat_processus).s_objet_erreur =
3604: (*l_element_courant).donnee;
3605:
3606: l_element_courant = (*l_element_courant).suivant;
3607:
3608: while(l_element_courant != NULL)
3609: {
3610: if ((*(*l_element_courant).donnee).type == FCT)
3611: {
3612: (*s_etat_processus).instruction_courante =
3613: (*((struct_fonction *)
3614: (*(*l_element_courant).donnee)
3615: .objet)).nom_fonction;
3616: fonction = (*((struct_fonction *)
3617: (*(*l_element_courant).donnee)
3618: .objet)).fonction;
3619:
3620: if (recherche_variable(s_etat_processus,
3621: (*s_etat_processus)
3622: .instruction_courante) == d_faux)
3623: {
3624: (*s_etat_processus).erreur_systeme
3625: = d_es;
3626:
3627: /*
3628: * Traitement de la pile système par les
3629: * différentes instructions.
3630: */
3631:
3632: if (TEST(instruction_if) ||
3633: TEST(instruction_iferr) ||
3634: TEST(instruction_do) ||
3635: TEST(instruction_while) ||
3636: TEST(instruction_for) ||
3637: TEST(instruction_start) ||
3638: TEST(instruction_select) ||
3639: TEST(instruction_case) ||
3640: TEST(vers_niveau_superieur))
3641: {
3642: if (TEST(vers_niveau_superieur))
3643: {
3644: analyse(s_etat_processus,
3645: vers_niveau_superieur);
3646:
3647: if ((*s_etat_processus)
3648: .erreur_systeme != d_es)
3649: {
3650: (*s_etat_processus)
3651: .instruction_courante =
3652: instruction_courante;
3653: return(d_erreur);
3654: }
3655: }
3656: else
3657: {
3658: empilement_pile_systeme(
3659: s_etat_processus);
3660:
3661: if ((*s_etat_processus)
3662: .erreur_systeme != d_es)
3663: {
3664: if (presence_egalite ==
3665: d_vrai)
3666: {
3667: liberation(
3668: s_etat_processus,
3669: s_objet_evalue);
3670: }
3671:
3672: (*s_etat_processus)
3673: .instruction_courante =
3674: instruction_courante;
3675: return(d_erreur);
3676: }
3677: }
3678: }
3679: else if (TEST(instruction_end) ||
3680: TEST(instruction_next) ||
3681: TEST(instruction_step) ||
3682: TEST(vers_niveau_inferieur))
3683: {
3684: if (TEST(vers_niveau_inferieur))
3685: {
3686: analyse(s_etat_processus,
3687: vers_niveau_inferieur);
3688:
3689: if ((*s_etat_processus)
3690: .erreur_systeme != d_es)
3691: {
3692: (*s_etat_processus)
3693: .instruction_courante =
3694: instruction_courante;
3695: return(d_erreur);
3696: }
3697: }
3698: else
3699: {
3700: depilement_pile_systeme(
3701: s_etat_processus);
3702:
3703: if ((*s_etat_processus)
3704: .erreur_systeme != d_es)
3705: {
3706: if (presence_egalite ==
3707: d_vrai)
3708: {
3709: liberation(
3710: s_etat_processus,
3711: s_objet_evalue);
3712: }
3713:
3714: (*s_etat_processus)
3715: .instruction_courante =
3716: instruction_courante;
3717: return(d_erreur);
3718: }
3719: }
3720: }
3721: }
3722: }
3723:
3724: l_element_courant =
3725: (*l_element_courant).suivant;
3726: }
3727:
3728: (*s_etat_processus).mode_execution_programme =
3729: registre_mode_execution_programme;
3730: (*s_etat_processus).instruction_courante =
3731: instruction_courante;
3732:
3733: if (presence_egalite == d_vrai)
3734: {
3735: liberation(s_etat_processus, s_objet_evalue);
3736: }
3737:
3738: if ((*s_etat_processus)
3739: .var_volatile_processus_pere == 0)
3740: {
3741: kill((*s_etat_processus)
3742: .pid_processus_pere, SIGALRM);
3743: }
3744: else
3745: {
3746: (*s_etat_processus).var_volatile_alarme = -1;
3747: }
3748:
3749: (*s_etat_processus).erreur_execution =
3750: registre_erreur_execution;
3751: (*s_etat_processus).erreur_systeme =
3752: registre_erreur_systeme;
3753: (*s_etat_processus).exception =
3754: registre_exception;
3755: return(d_erreur);
3756: }
3757: }
3758:
3759: if ((*s_etat_processus).erreur_systeme != d_es)
3760: {
3761: if (presence_egalite == d_vrai)
3762: {
3763: liberation(s_etat_processus, s_objet_evalue);
3764: }
3765:
3766: if ((*s_etat_processus).var_volatile_processus_pere
3767: == 0)
3768: {
3769: kill((*s_etat_processus)
3770: .pid_processus_pere, SIGALRM);
3771: }
3772: else
3773: {
3774: (*s_etat_processus).var_volatile_alarme = -1;
3775: }
3776:
3777: (*s_etat_processus).instruction_courante =
3778: instruction_courante;
3779: return(d_erreur);
3780: }
3781: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3782: ((*s_etat_processus).exception != d_ep))
3783: {
3784: if ((*s_etat_processus).arret_si_exception == d_faux)
3785: {
3786: /*
3787: * Reprise sur erreur
3788: */
3789:
3790: if ((message = messages(s_etat_processus)) == NULL)
3791: {
3792: if (presence_egalite == d_vrai)
3793: {
3794: liberation(s_etat_processus,
3795: s_objet_evalue);
3796: }
3797:
3798: (*s_etat_processus).instruction_courante =
3799: instruction_courante;
3800: return(d_erreur);
3801: }
3802:
3803: free(message);
3804:
3805: while((*(*s_etat_processus).l_base_pile_systeme)
3806: .clause != 'R')
3807: {
3808: l_registre_atome = l_element_courant;
3809: l_element_courant =
3810: (*l_element_courant).suivant;
3811:
3812: if (l_element_courant == NULL)
3813: {
3814: /*
3815: * La fin de l'expression est atteinte,
3816: * le sequenceur reprend la main.
3817: */
3818:
3819: if (presence_egalite == d_vrai)
3820: {
3821: liberation(s_etat_processus,
3822: s_objet_evalue);
3823: }
3824:
3825: (*s_etat_processus)
3826: .mode_execution_programme =
3827: registre_mode_execution_programme;
3828: return(d_absence_erreur);
3829: }
3830:
3831: if ((*(*l_element_courant).donnee).type == FCT)
3832: {
3833: (*s_etat_processus).instruction_courante =
3834: (*((struct_fonction *)
3835: (*(*l_element_courant).donnee)
3836: .objet)).nom_fonction;
3837:
3838: if (recherche_variable(s_etat_processus,
3839: (*s_etat_processus)
3840: .instruction_courante) == d_faux)
3841: {
3842: (*s_etat_processus).erreur_systeme
3843: = d_es;
3844: fonction = (*((struct_fonction *)
3845: (*(*l_element_courant).donnee)
3846: .objet)).fonction;
3847:
3848: /*
3849: * Traitement de la pile système par les
3850: * différentes instructions.
3851: */
3852:
3853: if (TEST(instruction_if) ||
3854: TEST(instruction_iferr) ||
3855: TEST(instruction_do) ||
3856: TEST(instruction_while) ||
3857: TEST(instruction_for) ||
3858: TEST(instruction_start) ||
3859: TEST(instruction_select) ||
3860: TEST(instruction_case) ||
3861: TEST(vers_niveau_superieur))
3862: {
3863: if (TEST(vers_niveau_superieur))
3864: {
3865: registre_exception =
3866: (*s_etat_processus)
3867: .exception;
3868: registre_erreur_execution =
3869: (*s_etat_processus)
3870: .erreur_execution;
3871:
3872: analyse(s_etat_processus,
3873: vers_niveau_superieur);
3874:
3875: if ((*s_etat_processus)
3876: .erreur_systeme != d_es)
3877: {
3878: (*s_etat_processus)
3879: .instruction_courante =
3880: instruction_courante;
3881: return(d_erreur);
3882: }
3883:
3884: (*s_etat_processus).exception
3885: = registre_exception;
3886: (*s_etat_processus)
3887: .erreur_execution =
3888: registre_erreur_execution;
3889: }
3890: else
3891: {
3892: empilement_pile_systeme(
3893: s_etat_processus);
3894:
3895: if ((*s_etat_processus)
3896: .erreur_systeme != d_es)
3897: {
3898: if (presence_egalite ==
3899: d_vrai)
3900: {
3901: liberation(
3902: s_etat_processus,
3903: s_objet_evalue);
3904: }
3905:
3906: (*s_etat_processus)
3907: .instruction_courante =
3908: instruction_courante;
3909: return(d_erreur);
3910: }
3911: }
3912: }
3913: else if (TEST(instruction_end) ||
3914: TEST(instruction_next) ||
3915: TEST(instruction_step) ||
3916: TEST(vers_niveau_inferieur))
3917: {
3918: if (TEST(vers_niveau_inferieur))
3919: {
3920: registre_exception =
3921: (*s_etat_processus)
3922: .exception;
3923: registre_erreur_execution =
3924: (*s_etat_processus)
3925: .erreur_execution;
3926:
3927: analyse(s_etat_processus,
3928: vers_niveau_inferieur);
3929:
3930: if ((*s_etat_processus)
3931: .erreur_systeme != d_es)
3932: {
3933: (*s_etat_processus)
3934: .instruction_courante =
3935: instruction_courante;
3936: return(d_erreur);
3937: }
3938:
3939: (*s_etat_processus).exception
3940: = registre_exception;
3941: (*s_etat_processus)
3942: .erreur_execution =
3943: registre_erreur_execution;
3944: }
3945: else
3946: {
3947: depilement_pile_systeme(
3948: s_etat_processus);
3949:
3950: if ((*s_etat_processus)
3951: .erreur_systeme != d_es)
3952: {
3953: if (presence_egalite ==
3954: d_vrai)
3955: {
3956: liberation(
3957: s_etat_processus,
3958: s_objet_evalue);
3959: }
3960:
3961: (*s_etat_processus)
3962: .instruction_courante =
3963: instruction_courante;
3964: return(d_erreur);
3965: }
3966: }
3967: }
3968: }
3969: }
3970: }
3971:
3972: (*s_etat_processus).instruction_courante =
3973: instruction_courante;
3974: drapeau_then = d_faux;
3975:
3976: do
3977: {
3978: l_registre_atome = l_element_courant;
3979:
3980: if (l_element_courant == NULL)
3981: {
3982: /*
3983: * La fin de l'expression est atteinte,
3984: * le sequenceur reprend la main.
3985: */
3986:
3987: if (presence_egalite == d_vrai)
3988: {
3989: liberation(s_etat_processus,
3990: s_objet_evalue);
3991: }
3992:
3993: (*s_etat_processus)
3994: .mode_execution_programme =
3995: registre_mode_execution_programme;
3996: (*s_etat_processus).instruction_courante =
3997: instruction_courante;
3998: return(d_absence_erreur);
3999: }
4000:
4001: if ((*(*l_element_courant).donnee).type == FCT)
4002: {
4003: (*s_etat_processus)
4004: .instruction_courante =
4005: (*((struct_fonction *)
4006: (*(*l_element_courant).donnee)
4007: .objet)).nom_fonction;
4008: fonction = (*((struct_fonction *)
4009: (*(*l_element_courant).donnee)
4010: .objet)).fonction;
4011: (*s_etat_processus).instruction_courante =
4012: instruction_courante;
4013:
4014: drapeau_then = TEST(instruction_then)
4015: ? d_vrai : d_faux;
4016: }
4017:
4018: l_element_courant = (*l_element_courant)
4019: .suivant;
4020: } while(drapeau_then == d_faux);
4021:
4022: (*s_etat_processus).expression_courante =
4023: l_registre_atome;
4024:
4025: (*(*s_etat_processus).l_base_pile_systeme)
4026: .clause = 'X';
4027: instruction_then(s_etat_processus);
4028:
4029: (*s_etat_processus).exception = d_ep;
4030: (*s_etat_processus).erreur_execution = d_ex;
4031: }
4032: else if ((*s_etat_processus).mode_evaluation_expression
4033: == 'Y')
4034: {
4035: /*
4036: * Reprise sur erreur
4037: */
4038:
4039: while(l_element_courant != NULL)
4040: {
4041: if ((*(*l_element_courant).donnee).type == FCT)
4042: {
4043: (*s_etat_processus).instruction_courante =
4044: (*((struct_fonction *)
4045: (*(*l_element_courant).donnee)
4046: .objet)).nom_fonction;
4047: fonction = (*((struct_fonction *)
4048: (*(*l_element_courant).donnee)
4049: .objet)).fonction;
4050:
4051: if (recherche_variable(s_etat_processus,
4052: (*s_etat_processus)
4053: .instruction_courante) == d_faux)
4054: {
4055: (*s_etat_processus).erreur_systeme
4056: = d_es;
4057:
4058: /*
4059: * Traitement de la pile système par les
4060: * différentes instructions.
4061: */
4062:
4063: if (TEST(instruction_if) ||
4064: TEST(instruction_iferr) ||
4065: TEST(instruction_do) ||
4066: TEST(instruction_while) ||
4067: TEST(instruction_for) ||
4068: TEST(instruction_start) ||
4069: TEST(instruction_select) ||
4070: TEST(instruction_case) ||
4071: TEST(vers_niveau_superieur))
4072: {
4073: if (TEST(vers_niveau_superieur))
4074: {
4075: analyse(s_etat_processus,
4076: vers_niveau_superieur);
4077:
4078: if ((*s_etat_processus)
4079: .erreur_systeme != d_es)
4080: {
4081: (*s_etat_processus)
4082: .instruction_courante =
4083: instruction_courante;
4084: return(d_erreur);
4085: }
4086: }
4087: else
4088: {
4089: empilement_pile_systeme(
4090: s_etat_processus);
4091:
4092: if ((*s_etat_processus)
4093: .erreur_systeme != d_es)
4094: {
4095: if (presence_egalite ==
4096: d_vrai)
4097: {
4098: liberation(
4099: s_etat_processus,
4100: s_objet_evalue);
4101: }
4102:
4103: (*s_etat_processus)
4104: .instruction_courante =
4105: instruction_courante;
4106: return(d_erreur);
4107: }
4108: }
4109: }
4110: else if (TEST(instruction_end) ||
4111: TEST(instruction_next) ||
4112: TEST(instruction_step) ||
4113: TEST(vers_niveau_inferieur))
4114: {
4115: if (TEST(vers_niveau_inferieur))
4116: {
4117: analyse(s_etat_processus,
4118: vers_niveau_inferieur);
4119:
4120: if ((*s_etat_processus)
4121: .erreur_systeme != d_es)
4122: {
4123: (*s_etat_processus)
4124: .instruction_courante =
4125: instruction_courante;
4126: return(d_erreur);
4127: }
4128: }
4129: else
4130: {
4131: depilement_pile_systeme(
4132: s_etat_processus);
4133:
4134: if ((*s_etat_processus)
4135: .erreur_systeme != d_es)
4136: {
4137: if (presence_egalite ==
4138: d_vrai)
4139: {
4140: liberation(
4141: s_etat_processus,
4142: s_objet_evalue);
4143: }
4144:
4145: (*s_etat_processus)
4146: .instruction_courante =
4147: instruction_courante;
4148: return(d_erreur);
4149: }
4150: }
4151: }
4152: }
4153: }
4154:
4155: l_element_courant =
4156: (*l_element_courant).suivant;
4157: }
4158:
4159: (*s_etat_processus).mode_execution_programme =
4160: registre_mode_execution_programme;
4161: (*s_etat_processus).instruction_courante =
4162: instruction_courante;
4163:
4164: (*s_etat_processus).exception = d_ep;
4165: (*s_etat_processus).erreur_execution = d_ex;
4166:
4167: erreur_evaluation = d_erreur;
4168: }
4169: else
4170: {
4171: // On ne détruit pas les variables pour les inclure
4172: // dans le fichier rpl-core.
4173:
4174: (*s_etat_processus).gel_liste_variables = d_vrai;
4175:
4176: registre_erreur_execution =
4177: (*s_etat_processus).erreur_execution;
4178: registre_exception =
4179: (*s_etat_processus).exception;
4180: registre_erreur_systeme =
4181: (*s_etat_processus).erreur_systeme;
4182:
4183: (*s_etat_processus).s_objet_errone = s_objet;
4184: (*s_etat_processus).s_objet_erreur =
4185: (*l_element_courant).donnee;
4186:
4187: l_element_courant = (*l_element_courant).suivant;
4188:
4189: while(l_element_courant != NULL)
4190: {
4191: if ((*(*l_element_courant).donnee).type == FCT)
4192: {
4193: (*s_etat_processus).instruction_courante =
4194: (*((struct_fonction *)
4195: (*(*l_element_courant).donnee)
4196: .objet)).nom_fonction;
4197: fonction = (*((struct_fonction *)
4198: (*(*l_element_courant).donnee)
4199: .objet)).fonction;
4200:
4201: if (recherche_variable(s_etat_processus,
4202: (*s_etat_processus)
4203: .instruction_courante) == d_faux)
4204: {
4205: (*s_etat_processus).erreur_systeme
4206: = d_es;
4207:
4208: /*
4209: * Traitement de la pile système par les
4210: * différentes instructions.
4211: */
4212:
4213: if (TEST(instruction_if) ||
4214: TEST(instruction_iferr) ||
4215: TEST(instruction_do) ||
4216: TEST(instruction_while) ||
4217: TEST(instruction_for) ||
4218: TEST(instruction_start) ||
4219: TEST(instruction_select) ||
4220: TEST(instruction_case) ||
4221: TEST(vers_niveau_superieur))
4222: {
4223: if (TEST(vers_niveau_superieur))
4224: {
4225: analyse(s_etat_processus,
4226: vers_niveau_superieur);
4227:
4228: if ((*s_etat_processus)
4229: .erreur_systeme != d_es)
4230: {
4231: (*s_etat_processus)
4232: .instruction_courante =
4233: instruction_courante;
4234: return(d_erreur);
4235: }
4236: }
4237: else
4238: {
4239: empilement_pile_systeme(
4240: s_etat_processus);
4241:
4242: if ((*s_etat_processus)
4243: .erreur_systeme != d_es)
4244: {
4245: if (presence_egalite ==
4246: d_vrai)
4247: {
4248: liberation(
4249: s_etat_processus,
4250: s_objet_evalue);
4251: }
4252:
4253: (*s_etat_processus)
4254: .instruction_courante =
4255: instruction_courante;
4256: return(d_erreur);
4257: }
4258: }
4259: }
4260: else if (TEST(instruction_end) ||
4261: TEST(instruction_next) ||
4262: TEST(instruction_step) ||
4263: TEST(vers_niveau_inferieur))
4264: {
4265: if (TEST(vers_niveau_inferieur))
4266: {
4267: analyse(s_etat_processus,
4268: vers_niveau_inferieur);
4269:
4270: if ((*s_etat_processus)
4271: .erreur_systeme != d_es)
4272: {
4273: (*s_etat_processus)
4274: .instruction_courante =
4275: instruction_courante;
4276: return(d_erreur);
4277: }
4278: }
4279: else
4280: {
4281: depilement_pile_systeme(
4282: s_etat_processus);
4283:
4284: if ((*s_etat_processus)
4285: .erreur_systeme != d_es)
4286: {
4287: if (presence_egalite ==
4288: d_vrai)
4289: {
4290: liberation(
4291: s_etat_processus,
4292: s_objet_evalue);
4293: }
4294:
4295: (*s_etat_processus)
4296: .instruction_courante =
4297: instruction_courante;
4298: return(d_erreur);
4299: }
4300: }
4301: }
4302: }
4303: }
4304:
4305: l_element_courant =
4306: (*l_element_courant).suivant;
4307: }
4308:
4309: (*s_etat_processus).mode_execution_programme =
4310: registre_mode_execution_programme;
4311: (*s_etat_processus).instruction_courante =
4312: instruction_courante;
4313:
4314: if (presence_egalite == d_vrai)
4315: {
4316: liberation(s_etat_processus, s_objet_evalue);
4317: }
4318:
4319: if ((*s_etat_processus)
4320: .var_volatile_processus_pere == 0)
4321: {
4322: kill((*s_etat_processus)
4323: .pid_processus_pere, SIGALRM);
4324: }
4325: else
4326: {
4327: (*s_etat_processus).var_volatile_alarme = -1;
4328: }
4329:
4330: (*s_etat_processus).erreur_execution =
4331: registre_erreur_execution;
4332: (*s_etat_processus).erreur_systeme =
4333: registre_erreur_systeme;
4334: (*s_etat_processus).exception =
4335: registre_exception;
4336: return(d_erreur);
4337: }
4338: }
4339: }
4340: else if ((*s_etat_processus).constante_symbolique == 'N')
4341: {
4342: if ((s_objet_elementaire = copie_objet(s_etat_processus,
4343: (*l_element_courant).donnee, 'P')) == NULL)
4344: {
4345: if (presence_egalite == d_vrai)
4346: {
4347: liberation(s_etat_processus, s_objet_evalue);
4348: }
4349:
4350: (*s_etat_processus).erreur_systeme =
4351: d_es_allocation_memoire;
4352: (*s_etat_processus).instruction_courante =
4353: instruction_courante;
4354: return(d_erreur);
4355: }
4356:
4357: presence_fonction = d_faux;
4358: presence_variable_partagee = d_faux;
4359:
4360: if (recherche_variable(s_etat_processus, (*((struct_nom *)
4361: (*s_objet_elementaire).objet)).nom) == d_faux)
4362: {
4363: (*s_etat_processus).erreur_systeme = d_es;
4364: presence_variable = d_faux;
4365: }
4366: else
4367: {
4368: if ((*s_etat_processus).traitement_symbolique == 'N')
4369: {
4370: if ((*s_etat_processus).s_liste_variables
4371: [(*s_etat_processus)
4372: .position_variable_courante].objet == NULL)
4373: {
4374: // Variable partagée
4375:
4376: if (pthread_mutex_lock(&((*(*s_etat_processus)
4377: .s_liste_variables_partagees).mutex))
4378: != 0)
4379: {
4380: (*s_etat_processus).erreur_systeme =
4381: d_es_processus;
4382: return(d_erreur);
4383: }
4384:
4385: presence_variable_partagee = d_faux;
4386:
4387: if (recherche_variable_partagee(
4388: s_etat_processus,
4389: ((*s_etat_processus).s_liste_variables
4390: [(*s_etat_processus)
4391: .position_variable_courante]).nom,
4392: ((*s_etat_processus).s_liste_variables
4393: [(*s_etat_processus)
4394: .position_variable_courante])
4395: .variable_partagee, 'E') == d_vrai)
4396: {
4397: presence_variable = d_vrai;
4398: presence_variable_partagee = d_vrai;
4399:
4400: if ((*((*(*s_etat_processus)
4401: .s_liste_variables_partagees).table
4402: [(*(*s_etat_processus)
4403: .s_liste_variables_partagees)
4404: .position_variable].objet)).type
4405: == ADR)
4406: {
4407: presence_fonction = d_vrai;
4408: }
4409:
4410: if ((type_evaluation == 'N') ||
4411: ((*((struct_nom *)
4412: (*(*l_element_courant).donnee)
4413: .objet)).symbole == d_faux))
4414: {
4415: if ((s_copie_variable_partagee =
4416: copie_objet(s_etat_processus,
4417: (*(*s_etat_processus)
4418: .s_liste_variables_partagees)
4419: .table[(*(*s_etat_processus)
4420: .s_liste_variables_partagees)
4421: .position_variable].objet, 'P'))
4422: == NULL)
4423: {
4424: if (pthread_mutex_unlock(
4425: &((*(*s_etat_processus)
4426: .s_liste_variables_partagees
4427: ).mutex)) != 0)
4428: {
4429: (*s_etat_processus)
4430: .erreur_systeme =
4431: d_es_processus;
4432: return(d_erreur);
4433: }
4434: }
4435: }
4436: else
4437: {
4438: s_copie_variable_partagee = NULL;
4439: }
4440:
4441: if (pthread_mutex_unlock(
4442: &((*(*s_etat_processus)
4443: .s_liste_variables_partagees)
4444: .mutex)) != 0)
4445: {
4446: (*s_etat_processus).erreur_systeme =
4447: d_es_processus;
4448: return(d_erreur);
4449: }
4450: }
4451: else
4452: {
4453: (*s_etat_processus).erreur_systeme = d_es;
4454: presence_variable = d_faux;
4455: presence_variable_partagee = d_faux;
4456:
4457: if (pthread_mutex_unlock(
4458: &((*(*s_etat_processus)
4459: .s_liste_variables_partagees)
4460: .mutex)) != 0)
4461: {
4462: (*s_etat_processus).erreur_systeme =
4463: d_es_processus;
4464: return(d_erreur);
4465: }
4466: }
4467: }
4468: else
4469: {
4470: presence_variable = d_vrai;
4471:
4472: if ((*((*s_etat_processus)
4473: .s_liste_variables
4474: [(*s_etat_processus)
4475: .position_variable_courante]
4476: .objet)).type == ADR)
4477: {
4478: presence_fonction = d_vrai;
4479: }
4480: }
4481: }
4482: else
4483: {
4484: presence_variable = d_faux;
4485: }
4486: }
4487:
4488: liberation(s_etat_processus, s_objet_elementaire);
4489:
4490: if (presence_fonction == d_vrai)
4491: {
4492: autorisation_empilement_programme = (*s_etat_processus)
4493: .autorisation_empilement_programme;
4494: registre_position_courante = (*s_etat_processus)
4495: .position_courante;
4496:
4497: empilement_pile_systeme(s_etat_processus);
4498:
4499: if ((*s_etat_processus).erreur_systeme != d_es)
4500: {
4501: if (presence_variable_partagee == d_vrai)
4502: {
4503: liberation(s_etat_processus,
4504: s_copie_variable_partagee);
4505: }
4506:
4507: if (presence_egalite == d_vrai)
4508: {
4509: liberation(s_etat_processus, s_objet_evalue);
4510: }
4511:
4512: (*s_etat_processus).instruction_courante =
4513: instruction_courante;
4514: return(d_erreur);
4515: }
4516:
4517: (*(*s_etat_processus).l_base_pile_systeme)
4518: .retour_definition = 'Y';
4519: (*(*s_etat_processus).l_base_pile_systeme)
4520: .origine_routine_evaluation = 'Y';
4521:
4522: (*s_etat_processus).mode_execution_programme = 'Y';
4523: (*s_etat_processus).autorisation_empilement_programme
4524: = 'N';
4525:
4526: (*(*s_etat_processus).l_base_pile_systeme)
4527: .niveau_courant = (*s_etat_processus)
4528: .niveau_courant;
4529:
4530: if (presence_variable_partagee == d_faux)
4531: {
4532: (*s_etat_processus).position_courante =
4533: (*((unsigned long *)
4534: ((*((*s_etat_processus).s_liste_variables
4535: [(*s_etat_processus)
4536: .position_variable_courante]
4537: .objet)).objet)));
4538: }
4539: else
4540: {
4541: (*s_etat_processus).position_courante =
4542: (*((unsigned long *)
4543: (*s_copie_variable_partagee).objet));
4544: liberation(s_etat_processus,
4545: s_copie_variable_partagee);
4546: }
4547:
4548: if ((*s_etat_processus).profilage == d_vrai)
4549: {
4550: profilage(s_etat_processus,
4551: (*s_etat_processus).s_liste_variables
4552: [(*s_etat_processus)
4553: .position_variable_courante].nom);
4554:
4555: if ((*s_etat_processus).erreur_systeme != d_es)
4556: {
4557: return(d_erreur);
4558: }
4559: }
4560:
4561: registre_evaluation_forcee =
4562: (*s_etat_processus).evaluation_forcee;
4563:
4564: if (type_evaluation == 'N')
4565: {
4566: (*s_etat_processus).evaluation_forcee = 'Y';
4567: }
4568:
4569: if (sequenceur(s_etat_processus) == d_erreur)
4570: {
4571: (*s_etat_processus).evaluation_forcee =
4572: registre_evaluation_forcee;
4573:
4574: if (presence_egalite == d_vrai)
4575: {
4576: liberation(s_etat_processus, s_objet_evalue);
4577: }
4578:
4579: (*s_etat_processus).instruction_courante =
4580: instruction_courante;
4581: (*s_etat_processus).mode_execution_programme =
4582: registre_mode_execution_programme;
4583: return(d_erreur);
4584: }
4585:
4586: (*s_etat_processus).evaluation_forcee =
4587: registre_evaluation_forcee;
4588: (*s_etat_processus).instruction_courante =
4589: instruction_courante;
4590: (*s_etat_processus).mode_execution_programme = 'N';
4591:
4592: depilement_pile_systeme(s_etat_processus);
4593:
4594: if ((*s_etat_processus).erreur_systeme != d_es)
4595: {
4596: if (presence_egalite == d_vrai)
4597: {
4598: liberation(s_etat_processus, s_objet_evalue);
4599: }
4600:
4601: return(d_erreur);
4602: }
4603:
4604: (*s_etat_processus).retour_routine_evaluation = 'N';
4605: (*s_etat_processus).position_courante =
4606: registre_position_courante;
4607: (*s_etat_processus).autorisation_empilement_programme =
4608: autorisation_empilement_programme;
4609: }
4610: else if (((type_evaluation == 'N') || ((*((struct_nom *)
4611: (*(*l_element_courant).donnee).objet)).symbole ==
4612: d_faux)) && (presence_variable == d_vrai))
4613: {
4614: if (type_evaluation == 'I')
4615: {
4616: if (presence_variable_partagee == d_faux)
4617: {
4618: if ((s_sous_objet =
4619: copie_objet(s_etat_processus,
4620: (*s_etat_processus)
4621: .s_liste_variables[(*s_etat_processus)
4622: .position_variable_courante].objet,
4623: 'P')) == NULL)
4624: {
4625: if (presence_variable_partagee == d_vrai)
4626: {
4627: liberation(s_etat_processus,
4628: s_copie_variable_partagee);
4629: }
4630:
4631: if (presence_egalite == d_vrai)
4632: {
4633: liberation(s_etat_processus,
4634: s_objet_evalue);
4635: }
4636:
4637: (*s_etat_processus).erreur_systeme =
4638: d_es_allocation_memoire;
4639: (*s_etat_processus).instruction_courante =
4640: instruction_courante;
4641: return(d_erreur);
4642: }
4643:
4644: if (empilement(s_etat_processus,
4645: &((*s_etat_processus).l_base_pile),
4646: s_sous_objet) == d_erreur)
4647: {
4648: if (presence_variable_partagee == d_vrai)
4649: {
4650: liberation(s_etat_processus,
4651: s_copie_variable_partagee);
4652: }
4653:
4654: if (presence_egalite == d_vrai)
4655: {
4656: liberation(s_etat_processus,
4657: s_objet_evalue);
4658: }
4659:
4660: return(d_erreur);
4661: }
4662: }
4663: else
4664: {
4665: if (empilement(s_etat_processus,
4666: &((*s_etat_processus).l_base_pile),
4667: s_copie_variable_partagee) == 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: }
4685: else
4686: {
4687: registre_evaluation_expression_compilee =
4688: (*s_etat_processus)
4689: .evaluation_expression_compilee;
4690:
4691: if (((*s_etat_processus).s_liste_variables
4692: [(*s_etat_processus)
4693: .position_variable_courante].origine == 'E')
4694: && ((*s_etat_processus).s_liste_variables
4695: [(*s_etat_processus)
4696: .position_variable_courante].niveau == 0))
4697: {
4698: (*s_etat_processus)
4699: .evaluation_expression_compilee = 'Y';
4700: }
4701: else
4702: {
4703: (*s_etat_processus)
4704: .evaluation_expression_compilee = 'N';
4705: }
4706:
4707: if (presence_variable_partagee == d_faux)
4708: {
4709: if ((*s_etat_processus).profilage == d_vrai)
4710: {
4711: profilage(s_etat_processus,
4712: (*s_etat_processus)
4713: .s_liste_variables
4714: [(*s_etat_processus)
4715: .position_variable_courante].nom);
4716:
4717: if ((*s_etat_processus).erreur_systeme
4718: != d_es)
4719: {
4720: return(d_erreur);
4721: }
4722: }
4723:
4724: registre_niveau_courant = (*(*s_etat_processus)
4725: .l_base_pile_systeme).niveau_courant;
4726: registre_retour_definition =
4727: (*(*s_etat_processus)
4728: .l_base_pile_systeme).retour_definition;
4729:
4730: (*(*s_etat_processus).l_base_pile_systeme)
4731: .retour_definition = 'Y';
4732: (*(*s_etat_processus).l_base_pile_systeme)
4733: .niveau_courant = (*s_etat_processus)
4734: .niveau_courant;
4735: empilement_pile_systeme(s_etat_processus);
4736:
4737: if (evaluation(s_etat_processus,
4738: (*s_etat_processus)
4739: .s_liste_variables[(*s_etat_processus)
4740: .position_variable_courante].objet,
4741: type_evaluation) == d_erreur)
4742: {
4743: depilement_pile_systeme(s_etat_processus);
4744:
4745: (*(*s_etat_processus).l_base_pile_systeme)
4746: .niveau_courant =
4747: (*(*s_etat_processus).l_base_pile_systeme)
4748: .retour_definition =
4749: registre_retour_definition;
4750:
4751: if ((*s_etat_processus).profilage == d_vrai)
4752: {
4753: profilage(s_etat_processus, NULL);
4754: }
4755:
4756: (*s_etat_processus)
4757: .evaluation_expression_compilee =
4758: registre_evaluation_expression_compilee;
4759:
4760: if (presence_egalite == d_vrai)
4761: {
4762: liberation(s_etat_processus,
4763: s_objet_evalue);
4764: }
4765:
4766: (*s_etat_processus).instruction_courante =
4767: instruction_courante;
4768: (*s_etat_processus).mode_execution_programme
4769: = registre_mode_execution_programme;
4770: return(d_erreur);
4771: }
4772:
4773: depilement_pile_systeme(s_etat_processus);
4774:
4775: (*(*s_etat_processus).l_base_pile_systeme)
4776: .niveau_courant =
4777: (*(*s_etat_processus).l_base_pile_systeme)
4778: .retour_definition =
4779: registre_retour_definition;
4780: }
4781: else
4782: {
4783: if ((*s_etat_processus).profilage == d_vrai)
4784: {
4785: profilage(s_etat_processus,
4786: (*s_etat_processus)
4787: .s_liste_variables
4788: [(*s_etat_processus)
4789: .position_variable_courante].nom);
4790:
4791: if ((*s_etat_processus).erreur_systeme
4792: != d_es)
4793: {
4794: return(d_erreur);
4795: }
4796: }
4797:
4798: empilement_pile_systeme(s_etat_processus);
4799: (*(*s_etat_processus).l_base_pile_systeme)
4800: .retour_definition = 'Y';
4801: (*(*s_etat_processus).l_base_pile_systeme)
4802: .niveau_courant = (*s_etat_processus)
4803: .niveau_courant;
4804: empilement_pile_systeme(s_etat_processus);
4805:
4806: if (evaluation(s_etat_processus,
4807: s_copie_variable_partagee,
4808: type_evaluation) == d_erreur)
4809: {
4810: depilement_pile_systeme(s_etat_processus);
4811: depilement_pile_systeme(s_etat_processus);
4812:
4813: liberation(s_etat_processus,
4814: s_copie_variable_partagee);
4815:
4816: if ((*s_etat_processus).profilage == d_vrai)
4817: {
4818: profilage(s_etat_processus, NULL);
4819: }
4820:
4821: (*s_etat_processus)
4822: .evaluation_expression_compilee =
4823: registre_evaluation_expression_compilee;
4824:
4825: if (presence_egalite == d_vrai)
4826: {
4827: liberation(s_etat_processus,
4828: s_objet_evalue);
4829: }
4830:
4831: (*s_etat_processus).instruction_courante =
4832: instruction_courante;
4833: (*s_etat_processus).mode_execution_programme
4834: = registre_mode_execution_programme;
4835: return(d_erreur);
4836: }
4837:
4838: depilement_pile_systeme(s_etat_processus);
4839: depilement_pile_systeme(s_etat_processus);
4840:
4841: liberation(s_etat_processus,
4842: s_copie_variable_partagee);
4843: }
4844:
4845: if ((*s_etat_processus).profilage == d_vrai)
4846: {
4847: profilage(s_etat_processus, NULL);
4848: }
4849:
4850: (*s_etat_processus)
4851: .evaluation_expression_compilee =
4852: registre_evaluation_expression_compilee;
4853: }
4854: }
4855: else
4856: {
4857: if (presence_variable_partagee == d_vrai)
4858: {
4859: liberation(s_etat_processus,
4860: s_copie_variable_partagee);
4861: }
4862:
4863: if ((s_objet_elementaire =
4864: copie_objet(s_etat_processus,
4865: (*l_element_courant).donnee, 'P')) == NULL)
4866: {
4867: if (presence_egalite == d_vrai)
4868: {
4869: liberation(s_etat_processus, s_objet_evalue);
4870: }
4871:
4872: (*s_etat_processus).erreur_systeme =
4873: d_es_allocation_memoire;
4874: (*s_etat_processus).instruction_courante =
4875: instruction_courante;
4876: return(d_erreur);
4877: }
4878:
4879: /*
4880: * Vérification du drapeau symbole pour
4881: * savoir si l'on met dans la pile le nom
4882: * ou le contenu de la variable.
4883: */
4884:
4885: if (((*((struct_nom *) (*s_objet_elementaire).objet))
4886: .symbole == d_faux) && ((*s_etat_processus)
4887: .traitement_symbolique == 'N'))
4888: {
4889: if (recherche_variable(s_etat_processus,
4890: (*((struct_nom *) (*s_objet_elementaire)
4891: .objet)).nom) == d_vrai)
4892: {
4893: if ((*s_etat_processus).s_liste_variables
4894: [(*s_etat_processus)
4895: .position_variable_courante].objet
4896: == NULL)
4897: {
4898: // Variable partagée
4899:
4900: if (pthread_mutex_lock(
4901: &((*(*s_etat_processus)
4902: .s_liste_variables_partagees)
4903: .mutex)) != 0)
4904: {
4905: (*s_etat_processus).erreur_systeme =
4906: d_es_processus;
4907: return(d_erreur);
4908: }
4909:
4910: if (recherche_variable_partagee(
4911: s_etat_processus,
4912: ((*s_etat_processus)
4913: .s_liste_variables
4914: [(*s_etat_processus)
4915: .position_variable_courante]).nom,
4916: ((*s_etat_processus)
4917: .s_liste_variables
4918: [(*s_etat_processus)
4919: .position_variable_courante])
4920: .variable_partagee, 'E') == d_vrai)
4921: {
4922: liberation(s_etat_processus,
4923: s_objet_elementaire);
4924:
4925: if ((s_objet_elementaire =
4926: copie_objet(s_etat_processus,
4927: (*(*s_etat_processus)
4928: .s_liste_variables_partagees)
4929: .table[(*(*s_etat_processus)
4930: .s_liste_variables_partagees)
4931: .position_variable].objet,
4932: 'P')) == NULL)
4933: {
4934: if (pthread_mutex_unlock(
4935: &((*(*s_etat_processus)
4936: .s_liste_variables_partagees
4937: ).mutex)) != 0)
4938: {
4939: (*s_etat_processus)
4940: .erreur_systeme =
4941: d_es_processus;
4942: return(d_erreur);
4943: }
4944:
4945: if (presence_egalite == d_vrai)
4946: {
4947: liberation(s_etat_processus,
4948: s_objet_evalue);
4949: }
4950:
4951: (*s_etat_processus).erreur_systeme =
4952: d_es_allocation_memoire;
4953: (*s_etat_processus)
4954: .instruction_courante =
4955: instruction_courante;
4956: return(d_erreur);
4957: }
4958: }
4959:
4960: if (pthread_mutex_unlock(
4961: &((*(*s_etat_processus)
4962: .s_liste_variables_partagees)
4963: .mutex)) != 0)
4964: {
4965: (*s_etat_processus).erreur_systeme =
4966: d_es_processus;
4967: return(d_erreur);
4968: }
4969: }
4970: else
4971: {
4972: // Variable privée
4973:
4974: liberation(s_etat_processus,
4975: s_objet_elementaire);
4976:
4977: if ((s_objet_elementaire =
4978: copie_objet(s_etat_processus,
4979: (*s_etat_processus)
4980: .s_liste_variables
4981: [(*s_etat_processus)
4982: .position_variable_courante].objet,
4983: 'P')) == NULL)
4984: {
4985: if (presence_egalite == d_vrai)
4986: {
4987: liberation(s_etat_processus,
4988: s_objet_evalue);
4989: }
4990:
4991: (*s_etat_processus).erreur_systeme =
4992: d_es_allocation_memoire;
4993: (*s_etat_processus)
4994: .instruction_courante =
4995: instruction_courante;
4996: return(d_erreur);
4997: }
4998: }
4999: }
5000: else
5001: {
5002: (*s_etat_processus).erreur_systeme = d_es;
5003:
5004: (*((struct_nom *) (*s_objet_elementaire)
5005: .objet)).symbole = d_vrai;
5006: }
5007: }
5008:
5009: if (empilement(s_etat_processus, &((*s_etat_processus)
5010: .l_base_pile), s_objet_elementaire) == d_erreur)
5011: {
5012: if (presence_egalite == d_vrai)
5013: {
5014: liberation(s_etat_processus, s_objet_evalue);
5015: }
5016:
5017: (*s_etat_processus).instruction_courante =
5018: instruction_courante;
5019: return(d_erreur);
5020: }
5021:
5022: if ((*s_etat_processus).erreur_execution ==
5023: d_ex_variable_non_definie)
5024: {
5025: (*s_etat_processus).erreur_execution = d_ex;
5026: }
5027: }
5028: }
5029: else
5030: {
5031: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
5032: == d_vrai) ? 'E' : 'N';
5033:
5034: if (type_evaluation == 'N')
5035: {
5036: cf(s_etat_processus, 35);
5037: }
5038: else
5039: {
5040: sf(s_etat_processus, 35);
5041: }
5042:
5043: analyse(s_etat_processus, NULL);
5044:
5045: if (registre_type_evaluation == 'E')
5046: {
5047: sf(s_etat_processus, 35);
5048: }
5049: else
5050: {
5051: cf(s_etat_processus, 35);
5052: }
5053:
5054: if (((*s_etat_processus).erreur_systeme != d_es) ||
5055: ((*s_etat_processus).erreur_execution != d_ex) ||
5056: ((*s_etat_processus).exception != d_ep))
5057: {
5058: if (presence_egalite == d_vrai)
5059: {
5060: liberation(s_etat_processus, s_objet_evalue);
5061: }
5062:
5063: (*s_etat_processus).instruction_courante =
5064: instruction_courante;
5065: (*s_etat_processus).mode_execution_programme =
5066: registre_mode_execution_programme;
5067: return(d_erreur);
5068: }
5069: }
5070:
5071: (*s_etat_processus).instruction_courante =
5072: instruction_courante;
5073: (*s_etat_processus).test_instruction = registre_test;
5074: (*s_etat_processus).instruction_valide =
5075: registre_instruction_valide;
5076: }
5077: else
5078: {
5079: if ((s_objet_tampon = copie_objet(s_etat_processus,
5080: (*l_element_courant).donnee, 'P')) == NULL)
5081: {
5082: (*s_etat_processus).erreur_systeme =
5083: d_es_allocation_memoire;
5084: (*s_etat_processus).instruction_courante =
5085: instruction_courante;
5086: return(d_erreur);
5087: }
5088:
5089: if (empilement(s_etat_processus, &((*s_etat_processus)
5090: .l_base_pile), s_objet_tampon) == d_erreur)
5091: {
5092: if (presence_egalite == d_vrai)
5093: {
5094: liberation(s_etat_processus, s_objet_evalue);
5095: }
5096:
5097: (*s_etat_processus).instruction_courante =
5098: instruction_courante;
5099: return(d_erreur);
5100: }
5101: }
5102:
5103: // Traitement de l'instruction EXIT en mode interactif
5104:
5105: if (l_element_courant != NULL)
5106: {
5107: l_element_courant = (*l_element_courant).suivant;
5108: }
5109: else
5110: {
5111: (*s_etat_processus).mode_execution_programme = 'Y';
5112:
5113: if ((*s_etat_processus).niveau_courant == 1)
5114: {
5115: (*s_etat_processus).debug_programme = d_faux;
5116: (*s_etat_processus).execution_pas_suivant = d_vrai;
5117: }
5118: }
5119:
5120: if ((*s_etat_processus).traitement_cycle_exit != 'N')
5121: {
5122: registre_expression_courante =
5123: (*s_etat_processus).expression_courante;
5124: (*s_etat_processus).expression_courante =
5125: l_element_courant;
5126:
5127: switch((*s_etat_processus).traitement_cycle_exit)
5128: {
5129: case 'C' :
5130: {
5131: instruction_cycle(s_etat_processus);
5132: break;
5133: }
5134:
5135: case 'E' :
5136: {
5137: instruction_exit(s_etat_processus);
5138: break;
5139: }
5140: }
5141:
5142: l_element_courant = (*s_etat_processus).expression_courante;
5143: (*s_etat_processus).expression_courante =
5144: registre_expression_courante;
5145: }
5146: }
5147:
5148: if (niveau_initial < (*s_etat_processus).niveau_courant)
5149: {
5150: /*
5151: * Retrait des variables dans le cas où l'évaluation de
5152: * l'expression a été interrompue
5153: */
5154:
5155: (*s_etat_processus).niveau_courant = niveau_initial;
5156:
5157: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5158: {
5159: if ((*s_etat_processus).s_liste_variables[n].niveau
5160: > niveau_initial)
5161: {
5162: m++;
5163: }
5164: }
5165:
5166: registre_variables = (*s_etat_processus).s_liste_variables;
5167: (*s_etat_processus).nombre_variables -= m;
5168:
5169: if (((*s_etat_processus).s_liste_variables = malloc(
5170: (*s_etat_processus).nombre_variables *
5171: sizeof(struct_variable))) == NULL)
5172: {
5173: if (presence_egalite == d_vrai)
5174: {
5175: liberation(s_etat_processus, s_objet_evalue);
5176: }
5177:
5178: (*s_etat_processus).instruction_courante = instruction_courante;
5179: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5180: return(d_erreur);
5181: }
5182:
5183: for(m = 0, n = 0; n < (*s_etat_processus).nombre_variables; n++)
5184: {
5185: if (registre_variables[n + m].niveau > niveau_initial)
5186: {
5187: free(registre_variables[n + m].nom);
5188: liberation(s_etat_processus,
5189: registre_variables[n + m].objet);
5190: m++;
5191: n--;
5192: }
5193: else
5194: {
5195: (*s_etat_processus).s_liste_variables[n] =
5196: registre_variables[n + m];
5197: }
5198: }
5199:
5200: free(registre_variables);
5201: }
5202:
5203: /*
5204: * Retrait des variables statiques créées dans l'expression
5205: */
5206:
5207: for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
5208: {
5209: if ((*s_etat_processus).s_liste_variables_statiques[n]
5210: .niveau > (*s_etat_processus).niveau_courant)
5211: {
5212: if (retrait_variable_statique(s_etat_processus,
5213: (*s_etat_processus).s_liste_variables_statiques[n].nom,
5214: (*s_etat_processus).s_liste_variables_statiques[n]
5215: .variable_statique) == d_erreur)
5216: {
5217: if (presence_egalite == d_vrai)
5218: {
5219: liberation(s_etat_processus, s_objet_evalue);
5220: }
5221:
5222: (*s_etat_processus).instruction_courante =
5223: instruction_courante;
5224: (*s_etat_processus).mode_execution_programme =
5225: registre_mode_execution_programme;
5226: return(d_erreur);
5227: }
5228: }
5229: }
5230:
5231: /*
5232: * Retrait des variables partagées créées dans l'expression
5233: */
5234:
5235: if (pthread_mutex_lock(&((*(*s_etat_processus)
5236: .s_liste_variables_partagees).mutex)) != 0)
5237: {
5238: (*s_etat_processus).erreur_systeme = d_es_processus;
5239: return(d_erreur);
5240: }
5241:
5242: for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
5243: .nombre_variables; n++)
5244: {
5245: if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
5246: .niveau > (*s_etat_processus).niveau_courant)
5247: {
5248: if (retrait_variable_partagee(s_etat_processus,
5249: (*(*s_etat_processus).s_liste_variables_partagees)
5250: .table[n].nom, (*(*s_etat_processus)
5251: .s_liste_variables_partagees).table[n]
5252: .variable_partagee) == d_erreur)
5253: {
5254: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5255: .s_liste_variables_partagees).mutex)) != 0)
5256: {
5257: (*s_etat_processus).erreur_systeme = d_es_processus;
5258: return(d_erreur);
5259: }
5260:
5261: if (presence_egalite == d_vrai)
5262: {
5263: liberation(s_etat_processus, s_objet_evalue);
5264: }
5265:
5266: (*s_etat_processus).instruction_courante =
5267: instruction_courante;
5268: (*s_etat_processus).mode_execution_programme =
5269: registre_mode_execution_programme;
5270: return(d_erreur);
5271: }
5272: }
5273: }
5274:
5275: 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 ((*s_etat_processus).var_volatile_requete_arret != 0)
5283: {
5284: // Restauration de la pile système
5285:
5286: while(pile_systeme_originelle !=
5287: (*s_etat_processus).l_base_pile_systeme)
5288: {
5289: depilement_pile_systeme(s_etat_processus);
5290: }
5291: }
5292:
5293: if (presence_egalite == d_vrai)
5294: {
5295: // Ajout du membre évalué lors de la première passe
5296:
5297: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5298: s_objet_evalue) == d_erreur)
5299: {
5300: (*s_etat_processus).instruction_courante =
5301: instruction_courante;
5302: return(d_erreur);
5303: }
5304:
5305: instruction_swap(s_etat_processus);
5306:
5307: if ((*s_etat_processus).erreur_execution != d_ex)
5308: {
5309: (*s_etat_processus).mode_execution_programme =
5310: registre_mode_execution_programme;
5311: (*s_etat_processus).autorisation_empilement_programme =
5312: autorisation_empilement_programme;
5313: (*s_etat_processus).instruction_courante = instruction_courante;
5314: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5315: registre_retour_definition;
5316:
5317: return(d_erreur);
5318: }
5319:
5320: instruction_egalite(s_etat_processus);
5321:
5322: if ((*s_etat_processus).erreur_execution != d_ex)
5323: {
5324: (*s_etat_processus).mode_execution_programme =
5325: registre_mode_execution_programme;
5326: (*s_etat_processus).autorisation_empilement_programme =
5327: autorisation_empilement_programme;
5328: (*s_etat_processus).instruction_courante = instruction_courante;
5329: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5330: registre_retour_definition;
5331:
5332: return(d_erreur);
5333: }
5334: }
5335:
5336: (*s_etat_processus).autorisation_empilement_programme =
5337: autorisation_empilement_programme;
5338: (*s_etat_processus).instruction_courante = instruction_courante;
5339: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5340: registre_retour_definition;
5341: }
5342: else if ((*s_objet).type == FCT)
5343: {
5344: (*s_etat_processus).instruction_courante =
5345: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
5346:
5347: analyse(s_etat_processus, (*((struct_fonction *)
5348: (*s_objet).objet)).fonction);
5349:
5350: (*s_etat_processus).instruction_courante = instruction_courante;
5351:
5352: if (((*s_etat_processus).erreur_systeme != d_es) ||
5353: ((*s_etat_processus).erreur_execution != d_ex) ||
5354: ((*s_etat_processus).exception != d_ep))
5355: {
5356: (*s_etat_processus).instruction_courante = instruction_courante;
5357: (*s_etat_processus).mode_execution_programme =
5358: registre_mode_execution_programme;
5359: return(d_erreur);
5360: }
5361: }
5362: else
5363: {
5364: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
5365: == NULL)
5366: {
5367: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5368: (*s_etat_processus).instruction_courante = instruction_courante;
5369: return(d_erreur);
5370: }
5371:
5372: if (empilement(s_etat_processus, &((*s_etat_processus)
5373: .l_base_pile), s_objet_tampon) == d_erreur)
5374: {
5375: (*s_etat_processus).instruction_courante = instruction_courante;
5376: return(d_erreur);
5377: }
5378: }
5379:
5380: (*s_etat_processus).mode_execution_programme =
5381: registre_mode_execution_programme;
5382:
5383: return((erreur_evaluation == d_absence_erreur)
5384: ? d_absence_erreur : d_erreur);
5385: }
5386:
5387: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>