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