![[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 |
En route vers la 4.4.1.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.1
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: free(s_objet_elementaire);
2134:
2135: if (presence_variable_partagee == d_vrai)
2136: {
2137: (*(*s_etat_processus)
2138: .pointeur_variable_courante).objet =
2139: NULL;
2140:
2141: if (pthread_mutex_unlock(
2142: &((*(*s_etat_processus)
2143: .s_liste_variables_partagees)
2144: .mutex)) != 0)
2145: {
2146: (*s_etat_processus).erreur_systeme =
2147: d_es_processus;
2148: }
2149: }
2150:
2151: if (presence_egalite == d_vrai)
2152: {
2153: liberation(s_etat_processus, s_objet_evalue);
2154: }
2155:
2156: (*s_etat_processus).erreur_execution =
2157: d_ex_element_inexistant;
2158: (*s_etat_processus).instruction_courante =
2159: instruction_courante;
2160: (*s_etat_processus).mode_execution_programme =
2161: registre_mode_execution_programme;
2162: return(d_erreur);
2163: }
2164:
2165: if ((*((*(*s_etat_processus).pointeur_variable_courante)
2166: .objet)).type == MIN)
2167: {
2168: if (((*s_objet_elementaire).objet = malloc(sizeof(
2169: integer8))) == NULL)
2170: {
2171: if (presence_variable_partagee == d_vrai)
2172: {
2173: (*(*s_etat_processus)
2174: .pointeur_variable_courante).objet =
2175: NULL;
2176:
2177: if (pthread_mutex_unlock(
2178: &((*(*s_etat_processus)
2179: .s_liste_variables_partagees)
2180: .mutex)) != 0)
2181: {
2182: (*s_etat_processus).erreur_systeme =
2183: d_es_processus;
2184: }
2185: }
2186:
2187: if (presence_egalite == d_vrai)
2188: {
2189: liberation(s_etat_processus,
2190: s_objet_evalue);
2191: }
2192:
2193: (*s_etat_processus).erreur_systeme =
2194: d_es_allocation_memoire;
2195: (*s_etat_processus).instruction_courante =
2196: instruction_courante;
2197: return(d_erreur);
2198: }
2199:
2200: (*s_objet_elementaire).type = INT;
2201: (*((integer8 *) (*s_objet_elementaire).objet)) =
2202: ((integer8 **) (*((struct_matrice *)
2203: (*((*(*s_etat_processus)
2204: .pointeur_variable_courante).objet))
2205: .objet)).tableau)[i - 1][j - 1];
2206: }
2207: else if ((*((*(*s_etat_processus)
2208: .pointeur_variable_courante).objet)).type
2209: == MRL)
2210: {
2211: if (((*s_objet_elementaire).objet = malloc(sizeof(
2212: real8))) == NULL)
2213: {
2214: if (presence_variable_partagee == d_vrai)
2215: {
2216: (*(*s_etat_processus)
2217: .pointeur_variable_courante).objet =
2218: NULL;
2219:
2220: if (pthread_mutex_unlock(
2221: &((*(*s_etat_processus)
2222: .s_liste_variables_partagees)
2223: .mutex)) != 0)
2224: {
2225: (*s_etat_processus).erreur_systeme =
2226: d_es_processus;
2227: }
2228: }
2229:
2230: if (presence_egalite == d_vrai)
2231: {
2232: liberation(s_etat_processus,
2233: s_objet_evalue);
2234: }
2235:
2236: (*s_etat_processus).erreur_systeme =
2237: d_es_allocation_memoire;
2238: (*s_etat_processus).instruction_courante =
2239: instruction_courante;
2240: return(d_erreur);
2241: }
2242:
2243: (*s_objet_elementaire).type = REL;
2244: (*((real8 *) (*s_objet_elementaire).objet)) =
2245: ((real8 **) (*((struct_matrice *)
2246: (*((*(*s_etat_processus)
2247: .pointeur_variable_courante).objet))
2248: .objet)).tableau)[i - 1][j - 1];
2249: }
2250: else if ((*((*(*s_etat_processus)
2251: .pointeur_variable_courante).objet)).type
2252: == MCX)
2253: {
2254: if (((*s_objet_elementaire).objet = malloc(sizeof(
2255: struct_complexe16))) == NULL)
2256: {
2257: if (presence_variable_partagee == d_vrai)
2258: {
2259: (*(*s_etat_processus)
2260: .pointeur_variable_courante).objet =
2261: NULL;
2262:
2263: if (pthread_mutex_unlock(
2264: &((*(*s_etat_processus)
2265: .s_liste_variables_partagees)
2266: .mutex)) != 0)
2267: {
2268: (*s_etat_processus).erreur_systeme =
2269: d_es_processus;
2270: }
2271: }
2272:
2273: if (presence_egalite == d_vrai)
2274: {
2275: liberation(s_etat_processus,
2276: s_objet_evalue);
2277: }
2278:
2279: (*s_etat_processus).erreur_systeme =
2280: d_es_allocation_memoire;
2281: (*s_etat_processus).instruction_courante =
2282: instruction_courante;
2283: return(d_erreur);
2284: }
2285:
2286: (*s_objet_elementaire).type = CPL;
2287: (*((struct_complexe16 *) (*s_objet_elementaire)
2288: .objet)).partie_reelle =
2289: ((struct_complexe16 **)
2290: (*((struct_matrice *)
2291: (*((*(*s_etat_processus)
2292: .pointeur_variable_courante).objet))
2293: .objet)).tableau)[i - 1][j - 1]
2294: .partie_reelle;
2295: (*((struct_complexe16 *) (*s_objet_elementaire)
2296: .objet)).partie_imaginaire =
2297: ((struct_complexe16 **)
2298: (*((struct_matrice *)
2299: (*((*(*s_etat_processus)
2300: .pointeur_variable_courante).objet))
2301: .objet)).tableau)[i - 1][j - 1]
2302: .partie_imaginaire;
2303: }
2304: }
2305:
2306: /*
2307: * Recherche de l'élément idoine dans la liste
2308: */
2309:
2310: else if (((*((*(*s_etat_processus)
2311: .pointeur_variable_courante).objet)).type == LST) &&
2312: ((*((struct_fonction *) (*(*l_element_courant)
2313: .donnee).objet)).nombre_arguments == 1))
2314: {
2315: if (depilement(s_etat_processus, &((*s_etat_processus)
2316: .l_base_pile), &s_objet_indice_i) == d_erreur)
2317: {
2318: free(s_objet_elementaire);
2319:
2320: if (presence_variable_partagee == d_vrai)
2321: {
2322: (*(*s_etat_processus)
2323: .pointeur_variable_courante).objet =
2324: NULL;
2325:
2326: if (pthread_mutex_unlock(
2327: &((*(*s_etat_processus)
2328: .s_liste_variables_partagees)
2329: .mutex)) != 0)
2330: {
2331: (*s_etat_processus).erreur_systeme =
2332: d_es_processus;
2333: }
2334: }
2335:
2336: if (presence_egalite == d_vrai)
2337: {
2338: liberation(s_etat_processus, s_objet_evalue);
2339: }
2340:
2341: (*s_etat_processus).erreur_execution =
2342: d_ex_manque_argument;
2343: (*s_etat_processus).instruction_courante =
2344: instruction_courante;
2345: (*s_etat_processus).mode_execution_programme =
2346: registre_mode_execution_programme;
2347: return(d_erreur);
2348: }
2349:
2350: if ((*s_objet_indice_i).type != INT)
2351: {
2352: liberation(s_etat_processus, s_objet_indice_i);
2353: free(s_objet_elementaire);
2354:
2355: if (presence_variable_partagee == d_vrai)
2356: {
2357: (*(*s_etat_processus)
2358: .pointeur_variable_courante).objet =
2359: NULL;
2360:
2361: if (pthread_mutex_unlock(
2362: &((*(*s_etat_processus)
2363: .s_liste_variables_partagees)
2364: .mutex)) != 0)
2365: {
2366: (*s_etat_processus).erreur_systeme =
2367: d_es_processus;
2368: }
2369: }
2370:
2371: if (presence_egalite == d_vrai)
2372: {
2373: liberation(s_etat_processus, s_objet_evalue);
2374: }
2375:
2376: (*s_etat_processus).erreur_execution =
2377: d_ex_erreur_type_argument;
2378: (*s_etat_processus).instruction_courante =
2379: instruction_courante;
2380: (*s_etat_processus).mode_execution_programme =
2381: registre_mode_execution_programme;
2382: return(d_erreur);
2383: }
2384:
2385: i = (*((integer8 *) (*s_objet_indice_i).objet));
2386:
2387: liberation(s_etat_processus, s_objet_indice_i);
2388:
2389: l_sous_element_courant = (*((*(*s_etat_processus)
2390: .pointeur_variable_courante).objet)).objet;
2391: j = 0;
2392:
2393: while(l_sous_element_courant != NULL)
2394: {
2395: if ((++j) == i)
2396: {
2397: break;
2398: }
2399:
2400: l_sous_element_courant =
2401: (*l_sous_element_courant).suivant;
2402: }
2403:
2404: if (j != i)
2405: {
2406: free(s_objet_elementaire);
2407:
2408: if (presence_variable_partagee == d_vrai)
2409: {
2410: (*(*s_etat_processus)
2411: .pointeur_variable_courante).objet =
2412: NULL;
2413:
2414: if (pthread_mutex_unlock(
2415: &((*(*s_etat_processus)
2416: .s_liste_variables_partagees)
2417: .mutex)) != 0)
2418: {
2419: (*s_etat_processus).erreur_systeme =
2420: d_es_processus;
2421: }
2422: }
2423:
2424: if (presence_egalite == d_vrai)
2425: {
2426: liberation(s_etat_processus, s_objet_evalue);
2427: }
2428:
2429: (*s_etat_processus).erreur_execution =
2430: d_ex_element_inexistant;
2431: (*s_etat_processus).instruction_courante =
2432: instruction_courante;
2433: (*s_etat_processus).mode_execution_programme =
2434: registre_mode_execution_programme;
2435: return(d_erreur);
2436: }
2437:
2438: free(s_objet_elementaire);
2439:
2440: if ((s_objet_elementaire =
2441: copie_objet(s_etat_processus,
2442: (*l_sous_element_courant).donnee, 'P')) == NULL)
2443: {
2444: if (presence_variable_partagee == d_vrai)
2445: {
2446: (*(*s_etat_processus)
2447: .pointeur_variable_courante).objet =
2448: NULL;
2449:
2450: if (pthread_mutex_unlock(
2451: &((*(*s_etat_processus)
2452: .s_liste_variables_partagees)
2453: .mutex)) != 0)
2454: {
2455: (*s_etat_processus).erreur_systeme =
2456: d_es_processus;
2457: }
2458: }
2459:
2460: if (presence_egalite == d_vrai)
2461: {
2462: liberation(s_etat_processus, s_objet_evalue);
2463: }
2464:
2465: (*s_etat_processus).erreur_systeme =
2466: d_es_allocation_memoire;
2467: (*s_etat_processus).instruction_courante =
2468: instruction_courante;
2469: return(d_erreur);
2470: }
2471: }
2472:
2473: /*
2474: * Recherche de l'élément idoine dans la table
2475: */
2476:
2477: else if (((*((*(*s_etat_processus)
2478: .pointeur_variable_courante).objet)).type == TBL) &&
2479: ((*((struct_fonction *) (*(*l_element_courant)
2480: .donnee).objet)).nombre_arguments == 1))
2481: {
2482: if (depilement(s_etat_processus, &((*s_etat_processus)
2483: .l_base_pile), &s_objet_indice_i) == d_erreur)
2484: {
2485: free(s_objet_elementaire);
2486:
2487: if (presence_variable_partagee == d_vrai)
2488: {
2489: (*(*s_etat_processus)
2490: .pointeur_variable_courante).objet =
2491: NULL;
2492:
2493: if (pthread_mutex_unlock(
2494: &((*(*s_etat_processus)
2495: .s_liste_variables_partagees)
2496: .mutex)) != 0)
2497: {
2498: (*s_etat_processus).erreur_systeme =
2499: d_es_processus;
2500: }
2501: }
2502:
2503: if (presence_egalite == d_vrai)
2504: {
2505: liberation(s_etat_processus, s_objet_evalue);
2506: }
2507:
2508: (*s_etat_processus).erreur_execution =
2509: d_ex_manque_argument;
2510: (*s_etat_processus).instruction_courante =
2511: instruction_courante;
2512: (*s_etat_processus).mode_execution_programme =
2513: registre_mode_execution_programme;
2514: return(d_erreur);
2515: }
2516:
2517: if ((*s_objet_indice_i).type != INT)
2518: {
2519: liberation(s_etat_processus, s_objet_indice_i);
2520: free(s_objet_elementaire);
2521:
2522: if (presence_variable_partagee == d_vrai)
2523: {
2524: (*(*s_etat_processus)
2525: .pointeur_variable_courante).objet =
2526: NULL;
2527:
2528: if (pthread_mutex_unlock(
2529: &((*(*s_etat_processus)
2530: .s_liste_variables_partagees)
2531: .mutex)) != 0)
2532: {
2533: (*s_etat_processus).erreur_systeme =
2534: d_es_processus;
2535: }
2536: }
2537:
2538: if (presence_egalite == d_vrai)
2539: {
2540: liberation(s_etat_processus, s_objet_evalue);
2541: }
2542:
2543: (*s_etat_processus).erreur_execution =
2544: d_ex_erreur_type_argument;
2545: (*s_etat_processus).instruction_courante =
2546: instruction_courante;
2547: (*s_etat_processus).mode_execution_programme =
2548: registre_mode_execution_programme;
2549: return(d_erreur);
2550: }
2551:
2552: i = (*((integer8 *) (*s_objet_indice_i).objet));
2553:
2554: liberation(s_etat_processus, s_objet_indice_i);
2555:
2556: if ((i < 1) || (i > (integer8) (*((struct_tableau *)
2557: (*(*(*s_etat_processus)
2558: .pointeur_variable_courante).objet)
2559: .objet)).nombre_elements))
2560: {
2561: free(s_objet_elementaire);
2562:
2563: if (presence_variable_partagee == d_vrai)
2564: {
2565: (*(*s_etat_processus)
2566: .pointeur_variable_courante).objet =
2567: NULL;
2568:
2569: if (pthread_mutex_unlock(
2570: &((*(*s_etat_processus)
2571: .s_liste_variables_partagees)
2572: .mutex)) != 0)
2573: {
2574: (*s_etat_processus).erreur_systeme =
2575: d_es_processus;
2576: }
2577: }
2578:
2579: if (presence_egalite == d_vrai)
2580: {
2581: liberation(s_etat_processus, s_objet_evalue);
2582: }
2583:
2584: (*s_etat_processus).erreur_execution =
2585: d_ex_element_inexistant;
2586: (*s_etat_processus).instruction_courante =
2587: instruction_courante;
2588: (*s_etat_processus).mode_execution_programme =
2589: registre_mode_execution_programme;
2590: return(d_erreur);
2591: }
2592:
2593: free(s_objet_elementaire);
2594:
2595: if ((s_objet_elementaire =
2596: copie_objet(s_etat_processus,
2597: (*((struct_tableau *) (*(*(*s_etat_processus)
2598: .pointeur_variable_courante).objet)
2599: .objet)).elements[i - 1], 'P')) == NULL)
2600: {
2601: if (presence_variable_partagee == d_vrai)
2602: {
2603: (*(*s_etat_processus)
2604: .pointeur_variable_courante).objet =
2605: NULL;
2606:
2607: if (pthread_mutex_unlock(
2608: &((*(*s_etat_processus)
2609: .s_liste_variables_partagees)
2610: .mutex)) != 0)
2611: {
2612: (*s_etat_processus).erreur_systeme =
2613: d_es_processus;
2614: }
2615: }
2616:
2617: if (presence_egalite == d_vrai)
2618: {
2619: liberation(s_etat_processus, s_objet_evalue);
2620: }
2621:
2622: (*s_etat_processus).erreur_systeme =
2623: d_es_allocation_memoire;
2624: (*s_etat_processus).instruction_courante =
2625: instruction_courante;
2626: return(d_erreur);
2627: }
2628: }
2629: else if (((*((*(*s_etat_processus)
2630: .pointeur_variable_courante).objet)).type == ALG) ||
2631: ((*((*(*s_etat_processus)
2632: .pointeur_variable_courante).objet)).type == RPN))
2633: {
2634: registre_evaluation_expression_compilee =
2635: (*s_etat_processus)
2636: .evaluation_expression_compilee;
2637:
2638: if (((*(*s_etat_processus).pointeur_variable_courante)
2639: .origine == 'E') && ((*(*s_etat_processus)
2640: .pointeur_variable_courante).niveau == 0))
2641: {
2642: (*s_etat_processus).evaluation_expression_compilee =
2643: 'Y';
2644: }
2645: else
2646: {
2647: (*s_etat_processus).evaluation_expression_compilee =
2648: 'N';
2649: }
2650:
2651: if (evaluation(s_etat_processus, (*(*s_etat_processus)
2652: .pointeur_variable_courante).objet,
2653: type_evaluation) == d_erreur)
2654: {
2655: (*s_etat_processus).evaluation_expression_compilee =
2656: registre_evaluation_expression_compilee;
2657:
2658: if (presence_variable_partagee == d_vrai)
2659: {
2660: (*(*s_etat_processus)
2661: .pointeur_variable_courante).objet =
2662: NULL;
2663:
2664: if (pthread_mutex_unlock(
2665: &((*(*s_etat_processus)
2666: .s_liste_variables_partagees)
2667: .mutex)) != 0)
2668: {
2669: (*s_etat_processus).erreur_systeme =
2670: d_es_processus;
2671: }
2672: }
2673:
2674: if (presence_egalite == d_vrai)
2675: {
2676: liberation(s_etat_processus, s_objet_evalue);
2677: }
2678:
2679: (*s_etat_processus).instruction_courante =
2680: instruction_courante;
2681: (*s_etat_processus).mode_execution_programme =
2682: registre_mode_execution_programme;
2683: return(d_erreur);
2684: }
2685:
2686: (*s_etat_processus).evaluation_expression_compilee =
2687: registre_evaluation_expression_compilee;
2688:
2689: free(s_objet_elementaire);
2690:
2691: if (depilement(s_etat_processus, &((*s_etat_processus)
2692: .l_base_pile), &s_objet_elementaire)
2693: == d_erreur)
2694: {
2695: if (presence_variable_partagee == d_vrai)
2696: {
2697: (*(*s_etat_processus)
2698: .pointeur_variable_courante).objet =
2699: NULL;
2700:
2701: if (pthread_mutex_unlock(
2702: &((*(*s_etat_processus)
2703: .s_liste_variables_partagees)
2704: .mutex)) != 0)
2705: {
2706: (*s_etat_processus).erreur_systeme =
2707: d_es_processus;
2708: }
2709: }
2710:
2711: if (presence_egalite == d_vrai)
2712: {
2713: liberation(s_etat_processus, s_objet_evalue);
2714: }
2715:
2716: (*s_etat_processus).erreur_execution =
2717: d_ex_manque_argument;
2718: (*s_etat_processus).instruction_courante =
2719: instruction_courante;
2720: (*s_etat_processus).mode_execution_programme =
2721: registre_mode_execution_programme;
2722: return(d_erreur);
2723: }
2724: }
2725: else if ((*((*(*s_etat_processus)
2726: .pointeur_variable_courante).objet)).type == ADR)
2727: {
2728: autorisation_empilement_programme = (*s_etat_processus)
2729: .autorisation_empilement_programme;
2730: registre_position_courante = (*s_etat_processus)
2731: .position_courante;
2732:
2733: empilement_pile_systeme(s_etat_processus);
2734:
2735: if ((*s_etat_processus).erreur_systeme != d_es)
2736: {
2737: if (presence_variable_partagee == d_vrai)
2738: {
2739: (*(*s_etat_processus)
2740: .pointeur_variable_courante).objet =
2741: NULL;
2742:
2743: if (pthread_mutex_unlock(
2744: &((*(*s_etat_processus)
2745: .s_liste_variables_partagees)
2746: .mutex)) != 0)
2747: {
2748: (*s_etat_processus).erreur_systeme =
2749: d_es_processus;
2750: }
2751: }
2752:
2753: if (presence_egalite == d_vrai)
2754: {
2755: liberation(s_etat_processus, s_objet_evalue);
2756: }
2757:
2758: (*s_etat_processus).instruction_courante =
2759: instruction_courante;
2760: return(d_erreur);
2761: }
2762:
2763: (*(*s_etat_processus).l_base_pile_systeme)
2764: .retour_definition = 'Y';
2765: (*(*s_etat_processus).l_base_pile_systeme)
2766: .origine_routine_evaluation = 'Y';
2767:
2768: (*s_etat_processus).mode_execution_programme = 'Y';
2769: (*s_etat_processus).autorisation_empilement_programme
2770: = 'N';
2771:
2772: (*(*s_etat_processus).l_base_pile_systeme)
2773: .niveau_courant = (*s_etat_processus)
2774: .niveau_courant;
2775:
2776: (*s_etat_processus).position_courante =
2777: (*((unsigned long *)
2778: ((*(*(*s_etat_processus)
2779: .pointeur_variable_courante).objet).objet)));
2780:
2781: if ((*s_etat_processus).profilage == d_vrai)
2782: {
2783: profilage(s_etat_processus,
2784: (*(*s_etat_processus)
2785: .pointeur_variable_courante).nom);
2786:
2787: if ((*s_etat_processus).erreur_systeme != d_es)
2788: {
2789: if (presence_variable_partagee == d_vrai)
2790: {
2791: (*(*s_etat_processus)
2792: .pointeur_variable_courante).objet =
2793: NULL;
2794:
2795: if (pthread_mutex_unlock(
2796: &((*(*s_etat_processus)
2797: .s_liste_variables_partagees)
2798: .mutex)) != 0)
2799: {
2800: (*s_etat_processus).erreur_systeme =
2801: d_es_processus;
2802: }
2803: }
2804:
2805: return(d_erreur);
2806: }
2807: }
2808:
2809: registre_evaluation_forcee =
2810: (*s_etat_processus).evaluation_forcee;
2811:
2812: if (type_evaluation == 'N')
2813: {
2814: (*s_etat_processus).evaluation_forcee = 'Y';
2815: }
2816:
2817: if (sequenceur(s_etat_processus) == d_erreur)
2818: {
2819: (*s_etat_processus).evaluation_forcee =
2820: registre_evaluation_forcee;
2821:
2822: if (presence_variable_partagee == d_vrai)
2823: {
2824: (*(*s_etat_processus)
2825: .pointeur_variable_courante).objet =
2826: NULL;
2827:
2828: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2829: .s_liste_variables_partagees)
2830: .mutex)) != 0)
2831: {
2832: (*s_etat_processus).erreur_systeme =
2833: d_es_processus;
2834: }
2835: }
2836:
2837: if (presence_egalite == d_vrai)
2838: {
2839: liberation(s_etat_processus, s_objet_evalue);
2840: }
2841:
2842: (*s_etat_processus).instruction_courante =
2843: instruction_courante;
2844: (*s_etat_processus).mode_execution_programme =
2845: registre_mode_execution_programme;
2846: return(d_erreur);
2847: }
2848:
2849: (*s_etat_processus).evaluation_forcee =
2850: registre_evaluation_forcee;
2851: (*s_etat_processus).instruction_courante =
2852: instruction_courante;
2853: (*s_etat_processus).mode_execution_programme = 'N';
2854:
2855: depilement_pile_systeme(s_etat_processus);
2856:
2857: if ((*s_etat_processus).erreur_systeme != d_es)
2858: {
2859: if (presence_variable_partagee == d_vrai)
2860: {
2861: (*(*s_etat_processus)
2862: .pointeur_variable_courante).objet =
2863: NULL;
2864:
2865: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2866: .s_liste_variables_partagees)
2867: .mutex)) != 0)
2868: {
2869: (*s_etat_processus).erreur_systeme =
2870: d_es_processus;
2871: }
2872: }
2873:
2874: if (presence_egalite == d_vrai)
2875: {
2876: liberation(s_etat_processus, s_objet_evalue);
2877: }
2878:
2879: return(d_erreur);
2880: }
2881:
2882: (*s_etat_processus).retour_routine_evaluation = 'N';
2883: (*s_etat_processus).position_courante =
2884: registre_position_courante;
2885: (*s_etat_processus).autorisation_empilement_programme =
2886: autorisation_empilement_programme;
2887:
2888: free(s_objet_elementaire);
2889:
2890: if (depilement(s_etat_processus, &((*s_etat_processus)
2891: .l_base_pile), &s_objet_elementaire)
2892: == d_erreur)
2893: {
2894: if (presence_variable_partagee == d_vrai)
2895: {
2896: (*(*s_etat_processus)
2897: .pointeur_variable_courante).objet =
2898: NULL;
2899:
2900: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2901: .s_liste_variables_partagees).mutex))
2902: != 0)
2903: {
2904: (*s_etat_processus).erreur_systeme =
2905: d_es_processus;
2906: }
2907: }
2908:
2909: if (presence_egalite == d_vrai)
2910: {
2911: liberation(s_etat_processus, s_objet_evalue);
2912: }
2913:
2914: (*s_etat_processus).erreur_execution =
2915: d_ex_manque_argument;
2916: (*s_etat_processus).instruction_courante =
2917: instruction_courante;
2918: (*s_etat_processus).mode_execution_programme =
2919: registre_mode_execution_programme;
2920: return(d_erreur);
2921: }
2922: }
2923: else
2924: {
2925: if (presence_variable_partagee == d_vrai)
2926: {
2927: (*(*s_etat_processus)
2928: .pointeur_variable_courante).objet =
2929: NULL;
2930:
2931: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2932: .s_liste_variables_partagees) .mutex)) != 0)
2933: {
2934: (*s_etat_processus).erreur_systeme =
2935: d_es_processus;
2936: }
2937: }
2938:
2939: if (presence_egalite == d_vrai)
2940: {
2941: liberation(s_etat_processus, s_objet_evalue);
2942: }
2943:
2944: (*s_etat_processus).erreur_execution =
2945: d_ex_element_inexistant;
2946: (*s_etat_processus).instruction_courante =
2947: instruction_courante;
2948: (*s_etat_processus).mode_execution_programme =
2949: registre_mode_execution_programme;
2950:
2951: return(d_erreur);
2952: }
2953:
2954: if (empilement(s_etat_processus, &((*s_etat_processus)
2955: .l_base_pile), s_objet_elementaire) == d_erreur)
2956: {
2957: if (presence_variable_partagee == d_vrai)
2958: {
2959: (*(*s_etat_processus)
2960: .pointeur_variable_courante).objet =
2961: NULL;
2962:
2963: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2964: .s_liste_variables_partagees).mutex)) != 0)
2965: {
2966: (*s_etat_processus).erreur_systeme =
2967: d_es_processus;
2968: }
2969: }
2970:
2971: if (presence_egalite == d_vrai)
2972: {
2973: liberation(s_etat_processus, s_objet_evalue);
2974: }
2975:
2976: (*s_etat_processus).instruction_courante =
2977: instruction_courante;
2978: return(d_erreur);
2979: }
2980:
2981: if (presence_variable_partagee == d_vrai)
2982: {
2983: (*(*s_etat_processus)
2984: .pointeur_variable_courante).objet = NULL;
2985:
2986: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2987: .s_liste_variables_partagees).mutex)) != 0)
2988: {
2989: (*s_etat_processus).erreur_systeme =
2990: d_es_processus;
2991: }
2992: }
2993: }
2994: }
2995: else if (((*(*l_element_courant).donnee).type == ALG)
2996: || ((*(*l_element_courant).donnee).type == RPN))
2997: {
2998: if (type_evaluation == 'I')
2999: {
3000: if ((s_objet_elementaire = copie_objet(s_etat_processus,
3001: (*l_element_courant).donnee, 'P')) == NULL)
3002: {
3003: if (presence_egalite == d_vrai)
3004: {
3005: liberation(s_etat_processus, s_objet_evalue);
3006: }
3007:
3008: (*s_etat_processus).erreur_systeme =
3009: d_es_allocation_memoire;
3010: (*s_etat_processus).instruction_courante =
3011: instruction_courante;
3012: return(d_erreur);
3013: }
3014:
3015: if (empilement(s_etat_processus, &((*s_etat_processus)
3016: .l_base_pile), s_objet_elementaire)
3017: == d_erreur)
3018: {
3019: if (presence_egalite == d_vrai)
3020: {
3021: liberation(s_etat_processus, s_objet_evalue);
3022: }
3023:
3024: (*s_etat_processus).instruction_courante =
3025: instruction_courante;
3026: return(d_erreur);
3027: }
3028: }
3029: else
3030: {
3031: if ((*s_etat_processus).autorisation_empilement_programme
3032: == 'N')
3033: {
3034: registre_evaluation_expression_compilee =
3035: (*s_etat_processus)
3036: .evaluation_expression_compilee;
3037:
3038: (*s_etat_processus).evaluation_expression_compilee
3039: = 'N';
3040:
3041: if (evaluation(s_etat_processus, (*l_element_courant)
3042: .donnee, type_evaluation) == d_erreur)
3043: {
3044: (*s_etat_processus).evaluation_expression_compilee
3045: = registre_evaluation_expression_compilee;
3046:
3047: if (presence_egalite == d_vrai)
3048: {
3049: liberation(s_etat_processus, s_objet_evalue);
3050: }
3051:
3052: (*s_etat_processus).instruction_courante =
3053: instruction_courante;
3054: (*s_etat_processus).mode_execution_programme =
3055: registre_mode_execution_programme;
3056: return(d_erreur);
3057: }
3058:
3059: (*s_etat_processus).evaluation_expression_compilee
3060: = registre_evaluation_expression_compilee;
3061: }
3062: else
3063: {
3064: if ((s_objet_elementaire =
3065: copie_objet(s_etat_processus,
3066: (*l_element_courant).donnee, 'P')) == NULL)
3067: {
3068: if (presence_egalite == d_vrai)
3069: {
3070: liberation(s_etat_processus, s_objet_evalue);
3071: }
3072:
3073: (*s_etat_processus).erreur_systeme =
3074: d_es_allocation_memoire;
3075: (*s_etat_processus).instruction_courante =
3076: instruction_courante;
3077: return(d_erreur);
3078: }
3079:
3080: if (empilement(s_etat_processus, &((*s_etat_processus)
3081: .l_base_pile), s_objet_elementaire)
3082: == d_erreur)
3083: {
3084: if (presence_egalite == d_vrai)
3085: {
3086: liberation(s_etat_processus, s_objet_evalue);
3087: }
3088:
3089: (*s_etat_processus).instruction_courante =
3090: instruction_courante;
3091: return(d_erreur);
3092: }
3093: }
3094: }
3095: }
3096: else if ((*(*l_element_courant).donnee).type == NOM)
3097: {
3098: registre_instruction_valide = (*s_etat_processus)
3099: .instruction_valide;
3100: registre_test = (*s_etat_processus).test_instruction;
3101: (*s_etat_processus).test_instruction = 'Y';
3102: (*s_etat_processus).instruction_courante = (*((struct_nom *)
3103: (*(*l_element_courant).donnee).objet)).nom;
3104:
3105: analyse(s_etat_processus, NULL);
3106:
3107: (*s_etat_processus).test_instruction = 'N';
3108:
3109: if ((*s_etat_processus).instruction_valide == 'Y')
3110: {
3111: registre_test_2 = (*s_etat_processus).test_instruction;
3112: (*s_etat_processus).test_instruction = 'N';
3113:
3114: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
3115: == d_vrai) ? 'E' : 'N';
3116:
3117: if (type_evaluation == 'N')
3118: {
3119: cf(s_etat_processus, 35);
3120: }
3121: else
3122: {
3123: sf(s_etat_processus, 35);
3124: }
3125:
3126: analyse(s_etat_processus, NULL);
3127:
3128: if (registre_type_evaluation == 'E')
3129: {
3130: sf(s_etat_processus, 35);
3131: }
3132: else
3133: {
3134: cf(s_etat_processus, 35);
3135: }
3136:
3137: (*s_etat_processus).test_instruction = registre_test_2;
3138:
3139: if ((*s_etat_processus).erreur_systeme != d_es)
3140: {
3141: if (presence_egalite == d_vrai)
3142: {
3143: liberation(s_etat_processus, s_objet_evalue);
3144: }
3145:
3146: if ((*s_etat_processus).var_volatile_processus_pere
3147: == 0)
3148: {
3149: kill((*s_etat_processus)
3150: .pid_processus_pere, SIGALRM);
3151: }
3152: else
3153: {
3154: (*s_etat_processus).var_volatile_alarme = -1;
3155: }
3156:
3157: (*s_etat_processus).instruction_courante =
3158: instruction_courante;
3159: return(d_erreur);
3160: }
3161: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3162: ((*s_etat_processus).exception != d_ep))
3163: {
3164: if ((*s_etat_processus).arret_si_exception == d_faux)
3165: {
3166: /*
3167: * Reprise sur erreur
3168: */
3169:
3170: if ((message = messages(s_etat_processus)) == NULL)
3171: {
3172: if (presence_egalite == d_vrai)
3173: {
3174: liberation(s_etat_processus,
3175: s_objet_evalue);
3176: }
3177:
3178: (*s_etat_processus).instruction_courante =
3179: instruction_courante;
3180: return(d_erreur);
3181: }
3182:
3183: free(message);
3184:
3185: while((*(*s_etat_processus).l_base_pile_systeme)
3186: .clause != 'R')
3187: {
3188: l_registre_atome = l_element_courant;
3189: l_element_courant =
3190: (*l_element_courant).suivant;
3191:
3192: if (l_element_courant == NULL)
3193: {
3194: /*
3195: * La fin de l'expression est atteinte,
3196: * le sequenceur reprend la main.
3197: */
3198:
3199: if (presence_egalite == d_vrai)
3200: {
3201: liberation(s_etat_processus,
3202: s_objet_evalue);
3203: }
3204:
3205: (*s_etat_processus)
3206: .mode_execution_programme =
3207: registre_mode_execution_programme;
3208: return(d_absence_erreur);
3209: }
3210:
3211: if ((*(*l_element_courant).donnee).type == FCT)
3212: {
3213: (*s_etat_processus).instruction_courante =
3214: (*((struct_fonction *)
3215: (*(*l_element_courant).donnee)
3216: .objet)).nom_fonction;
3217:
3218: if (recherche_variable(s_etat_processus,
3219: (*s_etat_processus)
3220: .instruction_courante) == d_faux)
3221: {
3222: (*s_etat_processus).erreur_systeme
3223: = d_es;
3224: fonction = (*((struct_fonction *)
3225: (*(*l_element_courant).donnee)
3226: .objet)).fonction;
3227:
3228: /*
3229: * Traitement de la pile système par les
3230: * différentes instructions.
3231: */
3232:
3233: if (TEST(instruction_if) ||
3234: TEST(instruction_iferr) ||
3235: TEST(instruction_do) ||
3236: TEST(instruction_while) ||
3237: TEST(instruction_for) ||
3238: TEST(instruction_start) ||
3239: TEST(instruction_select) ||
3240: TEST(instruction_case) ||
3241: TEST(vers_niveau_superieur))
3242: {
3243: if (TEST(vers_niveau_superieur))
3244: {
3245: registre_exception =
3246: (*s_etat_processus)
3247: .exception;
3248: registre_erreur_execution =
3249: (*s_etat_processus)
3250: .erreur_execution;
3251:
3252: analyse(s_etat_processus,
3253: vers_niveau_superieur);
3254:
3255: if ((*s_etat_processus)
3256: .erreur_systeme != d_es)
3257: {
3258: (*s_etat_processus)
3259: .instruction_courante =
3260: instruction_courante;
3261: return(d_erreur);
3262: }
3263:
3264: (*s_etat_processus).exception
3265: = registre_exception;
3266: (*s_etat_processus)
3267: .erreur_execution =
3268: registre_erreur_execution;
3269: }
3270: else
3271: {
3272: empilement_pile_systeme(
3273: s_etat_processus);
3274:
3275: if ((*s_etat_processus)
3276: .erreur_systeme != d_es)
3277: {
3278: if (presence_egalite ==
3279: d_vrai)
3280: {
3281: liberation(
3282: s_etat_processus,
3283: s_objet_evalue);
3284: }
3285:
3286: (*s_etat_processus)
3287: .instruction_courante =
3288: instruction_courante;
3289: return(d_erreur);
3290: }
3291: }
3292: }
3293: else if (TEST(instruction_end) ||
3294: TEST(instruction_next) ||
3295: TEST(instruction_step) ||
3296: TEST(vers_niveau_inferieur))
3297: {
3298: if (TEST(vers_niveau_inferieur))
3299: {
3300: registre_exception =
3301: (*s_etat_processus)
3302: .exception;
3303: registre_erreur_execution =
3304: (*s_etat_processus)
3305: .erreur_execution;
3306:
3307: analyse(s_etat_processus,
3308: vers_niveau_inferieur);
3309:
3310: if ((*s_etat_processus)
3311: .erreur_systeme != d_es)
3312: {
3313: (*s_etat_processus)
3314: .instruction_courante =
3315: instruction_courante;
3316: return(d_erreur);
3317: }
3318:
3319: (*s_etat_processus).exception
3320: = registre_exception;
3321: (*s_etat_processus)
3322: .erreur_execution =
3323: registre_erreur_execution;
3324: }
3325: else
3326: {
3327: depilement_pile_systeme(
3328: s_etat_processus);
3329:
3330: if ((*s_etat_processus)
3331: .erreur_systeme != d_es)
3332: {
3333: if (presence_egalite ==
3334: d_vrai)
3335: {
3336: liberation(
3337: s_etat_processus,
3338: s_objet_evalue);
3339: }
3340:
3341: (*s_etat_processus)
3342: .instruction_courante =
3343: instruction_courante;
3344: return(d_erreur);
3345: }
3346: }
3347: }
3348: }
3349: }
3350: }
3351:
3352: (*s_etat_processus).instruction_courante =
3353: instruction_courante;
3354: drapeau_then = d_faux;
3355:
3356: do
3357: {
3358: l_registre_atome = l_element_courant;
3359:
3360: if (l_element_courant == NULL)
3361: {
3362: /*
3363: * La fin de l'expression est atteinte,
3364: * le sequenceur reprend la main.
3365: */
3366:
3367: if (presence_egalite == d_vrai)
3368: {
3369: liberation(s_etat_processus,
3370: s_objet_evalue);
3371: }
3372:
3373: (*s_etat_processus)
3374: .mode_execution_programme =
3375: registre_mode_execution_programme;
3376: (*s_etat_processus).instruction_courante =
3377: instruction_courante;
3378: return(d_absence_erreur);
3379: }
3380:
3381: if ((*(*l_element_courant).donnee).type == FCT)
3382: {
3383: (*s_etat_processus)
3384: .instruction_courante =
3385: (*((struct_fonction *)
3386: (*(*l_element_courant).donnee)
3387: .objet)).nom_fonction;
3388: fonction = (*((struct_fonction *)
3389: (*(*l_element_courant).donnee)
3390: .objet)).fonction;
3391: (*s_etat_processus).instruction_courante =
3392: instruction_courante;
3393:
3394: drapeau_then = TEST(instruction_then)
3395: ? d_vrai : d_faux;
3396: }
3397:
3398: l_element_courant = (*l_element_courant)
3399: .suivant;
3400: } while(drapeau_then == d_faux);
3401:
3402: (*s_etat_processus).expression_courante =
3403: l_registre_atome;
3404:
3405: (*(*s_etat_processus).l_base_pile_systeme)
3406: .clause = 'X';
3407: instruction_then(s_etat_processus);
3408:
3409: (*s_etat_processus).exception = d_ep;
3410: (*s_etat_processus).erreur_execution = d_ex;
3411: }
3412: else if ((*s_etat_processus).mode_evaluation_expression
3413: == 'Y')
3414: {
3415: /*
3416: * Reprise sur erreur
3417: */
3418:
3419: while(l_element_courant != NULL)
3420: {
3421: if ((*(*l_element_courant).donnee).type == FCT)
3422: {
3423: (*s_etat_processus).instruction_courante =
3424: (*((struct_fonction *)
3425: (*(*l_element_courant).donnee)
3426: .objet)).nom_fonction;
3427: fonction = (*((struct_fonction *)
3428: (*(*l_element_courant).donnee)
3429: .objet)).fonction;
3430:
3431: if (recherche_variable(s_etat_processus,
3432: (*s_etat_processus)
3433: .instruction_courante) == d_faux)
3434: {
3435: (*s_etat_processus).erreur_systeme
3436: = d_es;
3437:
3438: /*
3439: * Traitement de la pile système par les
3440: * différentes instructions.
3441: */
3442:
3443: if (TEST(instruction_if) ||
3444: TEST(instruction_iferr) ||
3445: TEST(instruction_do) ||
3446: TEST(instruction_while) ||
3447: TEST(instruction_for) ||
3448: TEST(instruction_start) ||
3449: TEST(instruction_select) ||
3450: TEST(instruction_case) ||
3451: TEST(vers_niveau_superieur))
3452: {
3453: if (TEST(vers_niveau_superieur))
3454: {
3455: analyse(s_etat_processus,
3456: vers_niveau_superieur);
3457:
3458: if ((*s_etat_processus)
3459: .erreur_systeme != d_es)
3460: {
3461: (*s_etat_processus)
3462: .instruction_courante =
3463: instruction_courante;
3464: return(d_erreur);
3465: }
3466: }
3467: else
3468: {
3469: empilement_pile_systeme(
3470: s_etat_processus);
3471:
3472: if ((*s_etat_processus)
3473: .erreur_systeme != d_es)
3474: {
3475: if (presence_egalite ==
3476: d_vrai)
3477: {
3478: liberation(
3479: s_etat_processus,
3480: s_objet_evalue);
3481: }
3482:
3483: (*s_etat_processus)
3484: .instruction_courante =
3485: instruction_courante;
3486: return(d_erreur);
3487: }
3488: }
3489: }
3490: else if (TEST(instruction_end) ||
3491: TEST(instruction_next) ||
3492: TEST(instruction_step) ||
3493: TEST(vers_niveau_inferieur))
3494: {
3495: if (TEST(vers_niveau_inferieur))
3496: {
3497: analyse(s_etat_processus,
3498: vers_niveau_inferieur);
3499:
3500: if ((*s_etat_processus)
3501: .erreur_systeme != d_es)
3502: {
3503: (*s_etat_processus)
3504: .instruction_courante =
3505: instruction_courante;
3506: return(d_erreur);
3507: }
3508: }
3509: else
3510: {
3511: depilement_pile_systeme(
3512: s_etat_processus);
3513:
3514: if ((*s_etat_processus)
3515: .erreur_systeme != d_es)
3516: {
3517: if (presence_egalite ==
3518: d_vrai)
3519: {
3520: liberation(
3521: s_etat_processus,
3522: s_objet_evalue);
3523: }
3524:
3525: (*s_etat_processus)
3526: .instruction_courante =
3527: instruction_courante;
3528: return(d_erreur);
3529: }
3530: }
3531: }
3532: }
3533: }
3534:
3535: l_element_courant =
3536: (*l_element_courant).suivant;
3537: }
3538:
3539: (*s_etat_processus).mode_execution_programme =
3540: registre_mode_execution_programme;
3541: (*s_etat_processus).instruction_courante =
3542: instruction_courante;
3543:
3544: (*s_etat_processus).exception = d_ep;
3545: (*s_etat_processus).erreur_execution = d_ex;
3546:
3547: erreur_evaluation = d_erreur;
3548: }
3549: else
3550: {
3551: // On ne détruit pas les variables pour les inclure
3552: // dans le fichier rpl-core.
3553:
3554: (*s_etat_processus).gel_liste_variables = d_vrai;
3555:
3556: registre_erreur_execution =
3557: (*s_etat_processus).erreur_execution;
3558: registre_exception =
3559: (*s_etat_processus).exception;
3560: registre_erreur_systeme =
3561: (*s_etat_processus).erreur_systeme;
3562:
3563: (*s_etat_processus).s_objet_errone = s_objet;
3564: (*s_etat_processus).s_objet_erreur =
3565: (*l_element_courant).donnee;
3566:
3567: l_element_courant = (*l_element_courant).suivant;
3568:
3569: while(l_element_courant != NULL)
3570: {
3571: if ((*(*l_element_courant).donnee).type == FCT)
3572: {
3573: (*s_etat_processus).instruction_courante =
3574: (*((struct_fonction *)
3575: (*(*l_element_courant).donnee)
3576: .objet)).nom_fonction;
3577: fonction = (*((struct_fonction *)
3578: (*(*l_element_courant).donnee)
3579: .objet)).fonction;
3580:
3581: if (recherche_variable(s_etat_processus,
3582: (*s_etat_processus)
3583: .instruction_courante) == d_faux)
3584: {
3585: (*s_etat_processus).erreur_systeme
3586: = d_es;
3587:
3588: /*
3589: * Traitement de la pile système par les
3590: * différentes instructions.
3591: */
3592:
3593: if (TEST(instruction_if) ||
3594: TEST(instruction_iferr) ||
3595: TEST(instruction_do) ||
3596: TEST(instruction_while) ||
3597: TEST(instruction_for) ||
3598: TEST(instruction_start) ||
3599: TEST(instruction_select) ||
3600: TEST(instruction_case) ||
3601: TEST(vers_niveau_superieur))
3602: {
3603: if (TEST(vers_niveau_superieur))
3604: {
3605: analyse(s_etat_processus,
3606: vers_niveau_superieur);
3607:
3608: if ((*s_etat_processus)
3609: .erreur_systeme != d_es)
3610: {
3611: (*s_etat_processus)
3612: .instruction_courante =
3613: instruction_courante;
3614: return(d_erreur);
3615: }
3616: }
3617: else
3618: {
3619: empilement_pile_systeme(
3620: s_etat_processus);
3621:
3622: if ((*s_etat_processus)
3623: .erreur_systeme != d_es)
3624: {
3625: if (presence_egalite ==
3626: d_vrai)
3627: {
3628: liberation(
3629: s_etat_processus,
3630: s_objet_evalue);
3631: }
3632:
3633: (*s_etat_processus)
3634: .instruction_courante =
3635: instruction_courante;
3636: return(d_erreur);
3637: }
3638: }
3639: }
3640: else if (TEST(instruction_end) ||
3641: TEST(instruction_next) ||
3642: TEST(instruction_step) ||
3643: TEST(vers_niveau_inferieur))
3644: {
3645: if (TEST(vers_niveau_inferieur))
3646: {
3647: analyse(s_etat_processus,
3648: vers_niveau_inferieur);
3649:
3650: if ((*s_etat_processus)
3651: .erreur_systeme != d_es)
3652: {
3653: (*s_etat_processus)
3654: .instruction_courante =
3655: instruction_courante;
3656: return(d_erreur);
3657: }
3658: }
3659: else
3660: {
3661: depilement_pile_systeme(
3662: s_etat_processus);
3663:
3664: if ((*s_etat_processus)
3665: .erreur_systeme != d_es)
3666: {
3667: if (presence_egalite ==
3668: d_vrai)
3669: {
3670: liberation(
3671: s_etat_processus,
3672: s_objet_evalue);
3673: }
3674:
3675: (*s_etat_processus)
3676: .instruction_courante =
3677: instruction_courante;
3678: return(d_erreur);
3679: }
3680: }
3681: }
3682: }
3683: }
3684:
3685: l_element_courant =
3686: (*l_element_courant).suivant;
3687: }
3688:
3689: (*s_etat_processus).mode_execution_programme =
3690: registre_mode_execution_programme;
3691: (*s_etat_processus).instruction_courante =
3692: instruction_courante;
3693:
3694: if (presence_egalite == d_vrai)
3695: {
3696: liberation(s_etat_processus, s_objet_evalue);
3697: }
3698:
3699: if ((*s_etat_processus)
3700: .var_volatile_processus_pere == 0)
3701: {
3702: kill((*s_etat_processus)
3703: .pid_processus_pere, SIGALRM);
3704: }
3705: else
3706: {
3707: (*s_etat_processus).var_volatile_alarme = -1;
3708: }
3709:
3710: (*s_etat_processus).erreur_execution =
3711: registre_erreur_execution;
3712: (*s_etat_processus).erreur_systeme =
3713: registre_erreur_systeme;
3714: (*s_etat_processus).exception =
3715: registre_exception;
3716: return(d_erreur);
3717: }
3718: }
3719:
3720: if ((*s_etat_processus).erreur_systeme != d_es)
3721: {
3722: if (presence_egalite == d_vrai)
3723: {
3724: liberation(s_etat_processus, s_objet_evalue);
3725: }
3726:
3727: if ((*s_etat_processus).var_volatile_processus_pere
3728: == 0)
3729: {
3730: kill((*s_etat_processus)
3731: .pid_processus_pere, SIGALRM);
3732: }
3733: else
3734: {
3735: (*s_etat_processus).var_volatile_alarme = -1;
3736: }
3737:
3738: (*s_etat_processus).instruction_courante =
3739: instruction_courante;
3740: return(d_erreur);
3741: }
3742: else if (((*s_etat_processus).erreur_execution != d_ex) ||
3743: ((*s_etat_processus).exception != d_ep))
3744: {
3745: if ((*s_etat_processus).arret_si_exception == d_faux)
3746: {
3747: /*
3748: * Reprise sur erreur
3749: */
3750:
3751: if ((message = messages(s_etat_processus)) == NULL)
3752: {
3753: if (presence_egalite == d_vrai)
3754: {
3755: liberation(s_etat_processus,
3756: s_objet_evalue);
3757: }
3758:
3759: (*s_etat_processus).instruction_courante =
3760: instruction_courante;
3761: return(d_erreur);
3762: }
3763:
3764: free(message);
3765:
3766: while((*(*s_etat_processus).l_base_pile_systeme)
3767: .clause != 'R')
3768: {
3769: l_registre_atome = l_element_courant;
3770: l_element_courant =
3771: (*l_element_courant).suivant;
3772:
3773: if (l_element_courant == NULL)
3774: {
3775: /*
3776: * La fin de l'expression est atteinte,
3777: * le sequenceur reprend la main.
3778: */
3779:
3780: if (presence_egalite == d_vrai)
3781: {
3782: liberation(s_etat_processus,
3783: s_objet_evalue);
3784: }
3785:
3786: (*s_etat_processus)
3787: .mode_execution_programme =
3788: registre_mode_execution_programme;
3789: return(d_absence_erreur);
3790: }
3791:
3792: if ((*(*l_element_courant).donnee).type == FCT)
3793: {
3794: (*s_etat_processus).instruction_courante =
3795: (*((struct_fonction *)
3796: (*(*l_element_courant).donnee)
3797: .objet)).nom_fonction;
3798:
3799: if (recherche_variable(s_etat_processus,
3800: (*s_etat_processus)
3801: .instruction_courante) == d_faux)
3802: {
3803: (*s_etat_processus).erreur_systeme
3804: = d_es;
3805: fonction = (*((struct_fonction *)
3806: (*(*l_element_courant).donnee)
3807: .objet)).fonction;
3808:
3809: /*
3810: * Traitement de la pile système par les
3811: * différentes instructions.
3812: */
3813:
3814: if (TEST(instruction_if) ||
3815: TEST(instruction_iferr) ||
3816: TEST(instruction_do) ||
3817: TEST(instruction_while) ||
3818: TEST(instruction_for) ||
3819: TEST(instruction_start) ||
3820: TEST(instruction_select) ||
3821: TEST(instruction_case) ||
3822: TEST(vers_niveau_superieur))
3823: {
3824: if (TEST(vers_niveau_superieur))
3825: {
3826: registre_exception =
3827: (*s_etat_processus)
3828: .exception;
3829: registre_erreur_execution =
3830: (*s_etat_processus)
3831: .erreur_execution;
3832:
3833: analyse(s_etat_processus,
3834: vers_niveau_superieur);
3835:
3836: if ((*s_etat_processus)
3837: .erreur_systeme != d_es)
3838: {
3839: (*s_etat_processus)
3840: .instruction_courante =
3841: instruction_courante;
3842: return(d_erreur);
3843: }
3844:
3845: (*s_etat_processus).exception
3846: = registre_exception;
3847: (*s_etat_processus)
3848: .erreur_execution =
3849: registre_erreur_execution;
3850: }
3851: else
3852: {
3853: empilement_pile_systeme(
3854: s_etat_processus);
3855:
3856: if ((*s_etat_processus)
3857: .erreur_systeme != d_es)
3858: {
3859: if (presence_egalite ==
3860: d_vrai)
3861: {
3862: liberation(
3863: s_etat_processus,
3864: s_objet_evalue);
3865: }
3866:
3867: (*s_etat_processus)
3868: .instruction_courante =
3869: instruction_courante;
3870: return(d_erreur);
3871: }
3872: }
3873: }
3874: else if (TEST(instruction_end) ||
3875: TEST(instruction_next) ||
3876: TEST(instruction_step) ||
3877: TEST(vers_niveau_inferieur))
3878: {
3879: if (TEST(vers_niveau_inferieur))
3880: {
3881: registre_exception =
3882: (*s_etat_processus)
3883: .exception;
3884: registre_erreur_execution =
3885: (*s_etat_processus)
3886: .erreur_execution;
3887:
3888: analyse(s_etat_processus,
3889: vers_niveau_inferieur);
3890:
3891: if ((*s_etat_processus)
3892: .erreur_systeme != d_es)
3893: {
3894: (*s_etat_processus)
3895: .instruction_courante =
3896: instruction_courante;
3897: return(d_erreur);
3898: }
3899:
3900: (*s_etat_processus).exception
3901: = registre_exception;
3902: (*s_etat_processus)
3903: .erreur_execution =
3904: registre_erreur_execution;
3905: }
3906: else
3907: {
3908: depilement_pile_systeme(
3909: s_etat_processus);
3910:
3911: if ((*s_etat_processus)
3912: .erreur_systeme != d_es)
3913: {
3914: if (presence_egalite ==
3915: d_vrai)
3916: {
3917: liberation(
3918: s_etat_processus,
3919: s_objet_evalue);
3920: }
3921:
3922: (*s_etat_processus)
3923: .instruction_courante =
3924: instruction_courante;
3925: return(d_erreur);
3926: }
3927: }
3928: }
3929: }
3930: }
3931: }
3932:
3933: (*s_etat_processus).instruction_courante =
3934: instruction_courante;
3935: drapeau_then = d_faux;
3936:
3937: do
3938: {
3939: l_registre_atome = l_element_courant;
3940:
3941: if (l_element_courant == NULL)
3942: {
3943: /*
3944: * La fin de l'expression est atteinte,
3945: * le séquenceur reprend la main.
3946: */
3947:
3948: if (presence_egalite == d_vrai)
3949: {
3950: liberation(s_etat_processus,
3951: s_objet_evalue);
3952: }
3953:
3954: (*s_etat_processus)
3955: .mode_execution_programme =
3956: registre_mode_execution_programme;
3957: (*s_etat_processus).instruction_courante =
3958: instruction_courante;
3959: return(d_absence_erreur);
3960: }
3961:
3962: if ((*(*l_element_courant).donnee).type == FCT)
3963: {
3964: (*s_etat_processus)
3965: .instruction_courante =
3966: (*((struct_fonction *)
3967: (*(*l_element_courant).donnee)
3968: .objet)).nom_fonction;
3969: fonction = (*((struct_fonction *)
3970: (*(*l_element_courant).donnee)
3971: .objet)).fonction;
3972: (*s_etat_processus).instruction_courante =
3973: instruction_courante;
3974:
3975: drapeau_then = TEST(instruction_then)
3976: ? d_vrai : d_faux;
3977: }
3978:
3979: l_element_courant = (*l_element_courant)
3980: .suivant;
3981: } while(drapeau_then == d_faux);
3982:
3983: (*s_etat_processus).expression_courante =
3984: l_registre_atome;
3985:
3986: (*(*s_etat_processus).l_base_pile_systeme)
3987: .clause = 'X';
3988: instruction_then(s_etat_processus);
3989:
3990: (*s_etat_processus).exception = d_ep;
3991: (*s_etat_processus).erreur_execution = d_ex;
3992: }
3993: else if ((*s_etat_processus).mode_evaluation_expression
3994: == 'Y')
3995: {
3996: /*
3997: * Reprise sur erreur
3998: */
3999:
4000: while(l_element_courant != NULL)
4001: {
4002: if ((*(*l_element_courant).donnee).type == FCT)
4003: {
4004: (*s_etat_processus).instruction_courante =
4005: (*((struct_fonction *)
4006: (*(*l_element_courant).donnee)
4007: .objet)).nom_fonction;
4008: fonction = (*((struct_fonction *)
4009: (*(*l_element_courant).donnee)
4010: .objet)).fonction;
4011:
4012: if (recherche_variable(s_etat_processus,
4013: (*s_etat_processus)
4014: .instruction_courante) == d_faux)
4015: {
4016: (*s_etat_processus).erreur_systeme
4017: = d_es;
4018:
4019: /*
4020: * Traitement de la pile système par les
4021: * différentes instructions.
4022: */
4023:
4024: if (TEST(instruction_if) ||
4025: TEST(instruction_iferr) ||
4026: TEST(instruction_do) ||
4027: TEST(instruction_while) ||
4028: TEST(instruction_for) ||
4029: TEST(instruction_start) ||
4030: TEST(instruction_select) ||
4031: TEST(instruction_case) ||
4032: TEST(vers_niveau_superieur))
4033: {
4034: if (TEST(vers_niveau_superieur))
4035: {
4036: analyse(s_etat_processus,
4037: vers_niveau_superieur);
4038:
4039: if ((*s_etat_processus)
4040: .erreur_systeme != d_es)
4041: {
4042: (*s_etat_processus)
4043: .instruction_courante =
4044: instruction_courante;
4045: return(d_erreur);
4046: }
4047: }
4048: else
4049: {
4050: empilement_pile_systeme(
4051: s_etat_processus);
4052:
4053: if ((*s_etat_processus)
4054: .erreur_systeme != d_es)
4055: {
4056: if (presence_egalite ==
4057: d_vrai)
4058: {
4059: liberation(
4060: s_etat_processus,
4061: s_objet_evalue);
4062: }
4063:
4064: (*s_etat_processus)
4065: .instruction_courante =
4066: instruction_courante;
4067: return(d_erreur);
4068: }
4069: }
4070: }
4071: else if (TEST(instruction_end) ||
4072: TEST(instruction_next) ||
4073: TEST(instruction_step) ||
4074: TEST(vers_niveau_inferieur))
4075: {
4076: if (TEST(vers_niveau_inferieur))
4077: {
4078: analyse(s_etat_processus,
4079: vers_niveau_inferieur);
4080:
4081: if ((*s_etat_processus)
4082: .erreur_systeme != d_es)
4083: {
4084: (*s_etat_processus)
4085: .instruction_courante =
4086: instruction_courante;
4087: return(d_erreur);
4088: }
4089: }
4090: else
4091: {
4092: depilement_pile_systeme(
4093: s_etat_processus);
4094:
4095: if ((*s_etat_processus)
4096: .erreur_systeme != d_es)
4097: {
4098: if (presence_egalite ==
4099: d_vrai)
4100: {
4101: liberation(
4102: s_etat_processus,
4103: s_objet_evalue);
4104: }
4105:
4106: (*s_etat_processus)
4107: .instruction_courante =
4108: instruction_courante;
4109: return(d_erreur);
4110: }
4111: }
4112: }
4113: }
4114: }
4115:
4116: l_element_courant =
4117: (*l_element_courant).suivant;
4118: }
4119:
4120: (*s_etat_processus).mode_execution_programme =
4121: registre_mode_execution_programme;
4122: (*s_etat_processus).instruction_courante =
4123: instruction_courante;
4124:
4125: (*s_etat_processus).exception = d_ep;
4126: (*s_etat_processus).erreur_execution = d_ex;
4127:
4128: erreur_evaluation = d_erreur;
4129: }
4130: else
4131: {
4132: // On ne détruit pas les variables pour les inclure
4133: // dans le fichier rpl-core.
4134:
4135: (*s_etat_processus).gel_liste_variables = d_vrai;
4136:
4137: registre_erreur_execution =
4138: (*s_etat_processus).erreur_execution;
4139: registre_exception =
4140: (*s_etat_processus).exception;
4141: registre_erreur_systeme =
4142: (*s_etat_processus).erreur_systeme;
4143:
4144: (*s_etat_processus).s_objet_errone = s_objet;
4145: (*s_etat_processus).s_objet_erreur =
4146: (*l_element_courant).donnee;
4147:
4148: l_element_courant = (*l_element_courant).suivant;
4149:
4150: while(l_element_courant != NULL)
4151: {
4152: if ((*(*l_element_courant).donnee).type == FCT)
4153: {
4154: (*s_etat_processus).instruction_courante =
4155: (*((struct_fonction *)
4156: (*(*l_element_courant).donnee)
4157: .objet)).nom_fonction;
4158: fonction = (*((struct_fonction *)
4159: (*(*l_element_courant).donnee)
4160: .objet)).fonction;
4161:
4162: if (recherche_variable(s_etat_processus,
4163: (*s_etat_processus)
4164: .instruction_courante) == d_faux)
4165: {
4166: (*s_etat_processus).erreur_systeme
4167: = d_es;
4168:
4169: /*
4170: * Traitement de la pile système par les
4171: * différentes instructions.
4172: */
4173:
4174: if (TEST(instruction_if) ||
4175: TEST(instruction_iferr) ||
4176: TEST(instruction_do) ||
4177: TEST(instruction_while) ||
4178: TEST(instruction_for) ||
4179: TEST(instruction_start) ||
4180: TEST(instruction_select) ||
4181: TEST(instruction_case) ||
4182: TEST(vers_niveau_superieur))
4183: {
4184: if (TEST(vers_niveau_superieur))
4185: {
4186: analyse(s_etat_processus,
4187: vers_niveau_superieur);
4188:
4189: if ((*s_etat_processus)
4190: .erreur_systeme != d_es)
4191: {
4192: (*s_etat_processus)
4193: .instruction_courante =
4194: instruction_courante;
4195: return(d_erreur);
4196: }
4197: }
4198: else
4199: {
4200: empilement_pile_systeme(
4201: s_etat_processus);
4202:
4203: if ((*s_etat_processus)
4204: .erreur_systeme != d_es)
4205: {
4206: if (presence_egalite ==
4207: d_vrai)
4208: {
4209: liberation(
4210: s_etat_processus,
4211: s_objet_evalue);
4212: }
4213:
4214: (*s_etat_processus)
4215: .instruction_courante =
4216: instruction_courante;
4217: return(d_erreur);
4218: }
4219: }
4220: }
4221: else if (TEST(instruction_end) ||
4222: TEST(instruction_next) ||
4223: TEST(instruction_step) ||
4224: TEST(vers_niveau_inferieur))
4225: {
4226: if (TEST(vers_niveau_inferieur))
4227: {
4228: analyse(s_etat_processus,
4229: vers_niveau_inferieur);
4230:
4231: if ((*s_etat_processus)
4232: .erreur_systeme != d_es)
4233: {
4234: (*s_etat_processus)
4235: .instruction_courante =
4236: instruction_courante;
4237: return(d_erreur);
4238: }
4239: }
4240: else
4241: {
4242: depilement_pile_systeme(
4243: s_etat_processus);
4244:
4245: if ((*s_etat_processus)
4246: .erreur_systeme != d_es)
4247: {
4248: if (presence_egalite ==
4249: d_vrai)
4250: {
4251: liberation(
4252: s_etat_processus,
4253: s_objet_evalue);
4254: }
4255:
4256: (*s_etat_processus)
4257: .instruction_courante =
4258: instruction_courante;
4259: return(d_erreur);
4260: }
4261: }
4262: }
4263: }
4264: }
4265:
4266: l_element_courant =
4267: (*l_element_courant).suivant;
4268: }
4269:
4270: (*s_etat_processus).mode_execution_programme =
4271: registre_mode_execution_programme;
4272: (*s_etat_processus).instruction_courante =
4273: instruction_courante;
4274:
4275: if (presence_egalite == d_vrai)
4276: {
4277: liberation(s_etat_processus, s_objet_evalue);
4278: }
4279:
4280: if ((*s_etat_processus)
4281: .var_volatile_processus_pere == 0)
4282: {
4283: kill((*s_etat_processus)
4284: .pid_processus_pere, SIGALRM);
4285: }
4286: else
4287: {
4288: (*s_etat_processus).var_volatile_alarme = -1;
4289: }
4290:
4291: (*s_etat_processus).erreur_execution =
4292: registre_erreur_execution;
4293: (*s_etat_processus).erreur_systeme =
4294: registre_erreur_systeme;
4295: (*s_etat_processus).exception =
4296: registre_exception;
4297: return(d_erreur);
4298: }
4299: }
4300: }
4301: else if ((*s_etat_processus).constante_symbolique == 'N')
4302: {
4303: if ((s_objet_elementaire = copie_objet(s_etat_processus,
4304: (*l_element_courant).donnee, 'P')) == NULL)
4305: {
4306: if (presence_egalite == d_vrai)
4307: {
4308: liberation(s_etat_processus, s_objet_evalue);
4309: }
4310:
4311: (*s_etat_processus).erreur_systeme =
4312: d_es_allocation_memoire;
4313: (*s_etat_processus).instruction_courante =
4314: instruction_courante;
4315: return(d_erreur);
4316: }
4317:
4318: presence_fonction = d_faux;
4319: presence_variable_partagee = d_faux;
4320:
4321: if (recherche_variable(s_etat_processus, (*((struct_nom *)
4322: (*s_objet_elementaire).objet)).nom) == d_faux)
4323: {
4324: (*s_etat_processus).erreur_systeme = d_es;
4325: presence_variable = d_faux;
4326:
4327: if ((*s_etat_processus).autorisation_nom_implicite
4328: == 'N')
4329: {
4330: if ((*((struct_nom *) (*s_objet_elementaire).objet))
4331: .symbole == d_faux)
4332: {
4333: if (test_cfsf(s_etat_processus, 31) == d_vrai)
4334: {
4335: if (empilement_pile_last(s_etat_processus,
4336: 0) == d_erreur)
4337: {
4338: return(d_erreur);
4339: }
4340: }
4341:
4342: erreur_evaluation = d_erreur;
4343: (*s_etat_processus).erreur_execution =
4344: d_ex_nom_implicite;
4345:
4346: if (type_evaluation == 'I')
4347: {
4348: (*s_etat_processus)
4349: .derniere_erreur_evaluation =
4350: (*s_etat_processus)
4351: .erreur_execution;
4352: }
4353: }
4354: }
4355: }
4356: else
4357: {
4358: if ((*s_etat_processus).traitement_symbolique == 'N')
4359: {
4360: if ((*(*s_etat_processus)
4361: .pointeur_variable_courante).objet == NULL)
4362: {
4363: // Variable partagée
4364:
4365: if (pthread_mutex_lock(&((*(*s_etat_processus)
4366: .s_liste_variables_partagees).mutex))
4367: != 0)
4368: {
4369: (*s_etat_processus).erreur_systeme =
4370: d_es_processus;
4371: return(d_erreur);
4372: }
4373:
4374: presence_variable_partagee = d_faux;
4375:
4376: if (recherche_variable_partagee(
4377: s_etat_processus, (*(*s_etat_processus)
4378: .pointeur_variable_courante).nom,
4379: (*(*s_etat_processus)
4380: .pointeur_variable_courante)
4381: .variable_partagee, 'E') == d_vrai)
4382: {
4383: presence_variable = d_vrai;
4384: presence_variable_partagee = d_vrai;
4385:
4386: if ((*((*(*s_etat_processus)
4387: .s_liste_variables_partagees).table
4388: [(*(*s_etat_processus)
4389: .s_liste_variables_partagees)
4390: .position_variable].objet)).type
4391: == ADR)
4392: {
4393: presence_fonction = d_vrai;
4394: }
4395:
4396: if ((type_evaluation == 'N') ||
4397: ((*((struct_nom *)
4398: (*(*l_element_courant).donnee)
4399: .objet)).symbole == d_faux))
4400: {
4401: if ((s_copie_variable_partagee =
4402: copie_objet(s_etat_processus,
4403: (*(*s_etat_processus)
4404: .s_liste_variables_partagees)
4405: .table[(*(*s_etat_processus)
4406: .s_liste_variables_partagees)
4407: .position_variable].objet, 'P'))
4408: == NULL)
4409: {
4410: if (pthread_mutex_unlock(
4411: &((*(*s_etat_processus)
4412: .s_liste_variables_partagees
4413: ).mutex)) != 0)
4414: {
4415: (*s_etat_processus)
4416: .erreur_systeme =
4417: d_es_processus;
4418: return(d_erreur);
4419: }
4420: }
4421: }
4422: else
4423: {
4424: s_copie_variable_partagee = NULL;
4425: }
4426:
4427: if (pthread_mutex_unlock(
4428: &((*(*s_etat_processus)
4429: .s_liste_variables_partagees)
4430: .mutex)) != 0)
4431: {
4432: (*s_etat_processus).erreur_systeme =
4433: d_es_processus;
4434: return(d_erreur);
4435: }
4436: }
4437: else
4438: {
4439: (*s_etat_processus).erreur_systeme = d_es;
4440: presence_variable = d_faux;
4441: presence_variable_partagee = d_faux;
4442:
4443: if (pthread_mutex_unlock(
4444: &((*(*s_etat_processus)
4445: .s_liste_variables_partagees)
4446: .mutex)) != 0)
4447: {
4448: (*s_etat_processus).erreur_systeme =
4449: d_es_processus;
4450: return(d_erreur);
4451: }
4452: }
4453: }
4454: else
4455: {
4456: presence_variable = d_vrai;
4457:
4458: if ((*(*(*s_etat_processus)
4459: .pointeur_variable_courante).objet)
4460: .type == ADR)
4461: {
4462: presence_fonction = d_vrai;
4463: }
4464: }
4465: }
4466: else
4467: {
4468: presence_variable = d_faux;
4469: }
4470: }
4471:
4472: liberation(s_etat_processus, s_objet_elementaire);
4473:
4474: if (presence_fonction == d_vrai)
4475: {
4476: if ((*((struct_nom *) (*(*l_element_courant).donnee)
4477: .objet)).symbole == d_vrai)
4478: {
4479: // L'objet apparaît comme un symbole dans
4480: // l'expression en cours d'évaluation. On se
4481: // contente de l'empiler.
4482:
4483: if ((s_sous_objet = copie_objet(s_etat_processus,
4484: (*l_element_courant).donnee, 'P')) == NULL)
4485: {
4486: (*s_etat_processus).instruction_courante =
4487: instruction_courante;
4488:
4489: (*s_etat_processus).erreur_systeme =
4490: d_es_allocation_memoire;
4491: return(d_erreur);
4492: }
4493:
4494: if (empilement(s_etat_processus,
4495: &((*s_etat_processus).l_base_pile),
4496: s_sous_objet) == d_erreur)
4497: {
4498: (*s_etat_processus).instruction_courante =
4499: instruction_courante;
4500: liberation(s_etat_processus, s_sous_objet);
4501: return(d_erreur);
4502: }
4503: }
4504: else
4505: {
4506: autorisation_empilement_programme =
4507: (*s_etat_processus)
4508: .autorisation_empilement_programme;
4509: registre_position_courante = (*s_etat_processus)
4510: .position_courante;
4511:
4512: empilement_pile_systeme(s_etat_processus);
4513:
4514: if ((*s_etat_processus).erreur_systeme != d_es)
4515: {
4516: if (presence_variable_partagee == d_vrai)
4517: {
4518: liberation(s_etat_processus,
4519: s_copie_variable_partagee);
4520: }
4521:
4522: if (presence_egalite == d_vrai)
4523: {
4524: liberation(s_etat_processus,
4525: s_objet_evalue);
4526: }
4527:
4528: (*s_etat_processus).instruction_courante =
4529: instruction_courante;
4530: return(d_erreur);
4531: }
4532:
4533: (*(*s_etat_processus).l_base_pile_systeme)
4534: .retour_definition = 'Y';
4535: (*(*s_etat_processus).l_base_pile_systeme)
4536: .origine_routine_evaluation = 'Y';
4537:
4538: (*s_etat_processus).mode_execution_programme = 'Y';
4539: (*s_etat_processus)
4540: .autorisation_empilement_programme = 'N';
4541:
4542: (*(*s_etat_processus).l_base_pile_systeme)
4543: .niveau_courant = (*s_etat_processus)
4544: .niveau_courant;
4545:
4546: if (presence_variable_partagee == d_faux)
4547: {
4548: (*s_etat_processus).position_courante =
4549: (*((unsigned long *)
4550: ((*(*(*s_etat_processus)
4551: .pointeur_variable_courante)
4552: .objet).objet)));
4553: }
4554: else
4555: {
4556: (*s_etat_processus).position_courante =
4557: (*((unsigned long *)
4558: (*s_copie_variable_partagee).objet));
4559: liberation(s_etat_processus,
4560: s_copie_variable_partagee);
4561: }
4562:
4563: if ((*s_etat_processus).profilage == d_vrai)
4564: {
4565: profilage(s_etat_processus,
4566: (*(*s_etat_processus)
4567: .pointeur_variable_courante).nom);
4568:
4569: if ((*s_etat_processus).erreur_systeme != d_es)
4570: {
4571: return(d_erreur);
4572: }
4573: }
4574:
4575: registre_evaluation_forcee =
4576: (*s_etat_processus).evaluation_forcee;
4577:
4578: if (type_evaluation == 'N')
4579: {
4580: (*s_etat_processus).evaluation_forcee = 'Y';
4581: }
4582:
4583: if (sequenceur(s_etat_processus) == d_erreur)
4584: {
4585: (*s_etat_processus).evaluation_forcee =
4586: registre_evaluation_forcee;
4587:
4588: if (presence_egalite == d_vrai)
4589: {
4590: liberation(s_etat_processus,
4591: s_objet_evalue);
4592: }
4593:
4594: (*s_etat_processus).instruction_courante =
4595: instruction_courante;
4596: (*s_etat_processus).mode_execution_programme =
4597: registre_mode_execution_programme;
4598: return(d_erreur);
4599: }
4600:
4601: (*s_etat_processus).evaluation_forcee =
4602: registre_evaluation_forcee;
4603: (*s_etat_processus).instruction_courante =
4604: instruction_courante;
4605: (*s_etat_processus).mode_execution_programme = 'N';
4606:
4607: depilement_pile_systeme(s_etat_processus);
4608:
4609: if ((*s_etat_processus).erreur_systeme != d_es)
4610: {
4611: if (presence_egalite == d_vrai)
4612: {
4613: liberation(s_etat_processus,
4614: s_objet_evalue);
4615: }
4616:
4617: return(d_erreur);
4618: }
4619:
4620: (*s_etat_processus).retour_routine_evaluation = 'N';
4621: (*s_etat_processus).position_courante =
4622: registre_position_courante;
4623: (*s_etat_processus)
4624: .autorisation_empilement_programme =
4625: autorisation_empilement_programme;
4626: }
4627: }
4628: else if (((type_evaluation == 'N') || ((*((struct_nom *)
4629: (*(*l_element_courant).donnee).objet)).symbole ==
4630: d_faux)) && (presence_variable == d_vrai))
4631: {
4632: if (type_evaluation == 'I')
4633: {
4634: if (presence_variable_partagee == d_faux)
4635: {
4636: if ((s_sous_objet =
4637: copie_objet(s_etat_processus,
4638: (*(*s_etat_processus)
4639: .pointeur_variable_courante).objet,
4640: 'P')) == NULL)
4641: {
4642: if (presence_variable_partagee == d_vrai)
4643: {
4644: liberation(s_etat_processus,
4645: s_copie_variable_partagee);
4646: }
4647:
4648: if (presence_egalite == d_vrai)
4649: {
4650: liberation(s_etat_processus,
4651: s_objet_evalue);
4652: }
4653:
4654: (*s_etat_processus).erreur_systeme =
4655: d_es_allocation_memoire;
4656: (*s_etat_processus).instruction_courante =
4657: instruction_courante;
4658: return(d_erreur);
4659: }
4660:
4661: if (empilement(s_etat_processus,
4662: &((*s_etat_processus).l_base_pile),
4663: s_sous_objet) == d_erreur)
4664: {
4665: if (presence_variable_partagee == d_vrai)
4666: {
4667: liberation(s_etat_processus,
4668: s_copie_variable_partagee);
4669: }
4670:
4671: if (presence_egalite == d_vrai)
4672: {
4673: liberation(s_etat_processus,
4674: s_objet_evalue);
4675: }
4676:
4677: return(d_erreur);
4678: }
4679: }
4680: else
4681: {
4682: if (empilement(s_etat_processus,
4683: &((*s_etat_processus).l_base_pile),
4684: s_copie_variable_partagee) == d_erreur)
4685: {
4686: if (presence_variable_partagee == d_vrai)
4687: {
4688: liberation(s_etat_processus,
4689: s_copie_variable_partagee);
4690: }
4691:
4692: if (presence_egalite == d_vrai)
4693: {
4694: liberation(s_etat_processus,
4695: s_objet_evalue);
4696: }
4697:
4698: return(d_erreur);
4699: }
4700: }
4701: }
4702: else
4703: {
4704: registre_evaluation_expression_compilee =
4705: (*s_etat_processus)
4706: .evaluation_expression_compilee;
4707:
4708: if (((*(*s_etat_processus)
4709: .pointeur_variable_courante)
4710: .origine == 'E') && ((*(*s_etat_processus)
4711: .pointeur_variable_courante).niveau == 0))
4712: {
4713: (*s_etat_processus)
4714: .evaluation_expression_compilee = 'Y';
4715: }
4716: else
4717: {
4718: (*s_etat_processus)
4719: .evaluation_expression_compilee = 'N';
4720: }
4721:
4722: if (presence_variable_partagee == d_faux)
4723: {
4724: if ((*s_etat_processus).profilage == d_vrai)
4725: {
4726: profilage(s_etat_processus,
4727: (*(*s_etat_processus)
4728: .pointeur_variable_courante).nom);
4729:
4730: if ((*s_etat_processus).erreur_systeme
4731: != d_es)
4732: {
4733: return(d_erreur);
4734: }
4735: }
4736:
4737: registre_niveau_courant = (*(*s_etat_processus)
4738: .l_base_pile_systeme).niveau_courant;
4739: registre_retour_definition =
4740: (*(*s_etat_processus)
4741: .l_base_pile_systeme).retour_definition;
4742:
4743: (*(*s_etat_processus).l_base_pile_systeme)
4744: .retour_definition = 'Y';
4745: (*(*s_etat_processus).l_base_pile_systeme)
4746: .niveau_courant = (*s_etat_processus)
4747: .niveau_courant;
4748: empilement_pile_systeme(s_etat_processus);
4749:
4750: if (evaluation(s_etat_processus,
4751: (*(*s_etat_processus)
4752: .pointeur_variable_courante).objet,
4753: type_evaluation) == d_erreur)
4754: {
4755: depilement_pile_systeme(s_etat_processus);
4756:
4757: (*(*s_etat_processus).l_base_pile_systeme)
4758: .niveau_courant =
4759: registre_niveau_courant;
4760: (*(*s_etat_processus).l_base_pile_systeme)
4761: .retour_definition =
4762: registre_retour_definition;
4763:
4764: if ((*s_etat_processus).profilage == d_vrai)
4765: {
4766: profilage(s_etat_processus, NULL);
4767: }
4768:
4769: (*s_etat_processus)
4770: .evaluation_expression_compilee =
4771: registre_evaluation_expression_compilee;
4772:
4773: if (presence_egalite == d_vrai)
4774: {
4775: liberation(s_etat_processus,
4776: s_objet_evalue);
4777: }
4778:
4779: (*s_etat_processus).instruction_courante =
4780: instruction_courante;
4781: (*s_etat_processus).mode_execution_programme
4782: = registre_mode_execution_programme;
4783: return(d_erreur);
4784: }
4785:
4786: depilement_pile_systeme(s_etat_processus);
4787:
4788: (*(*s_etat_processus).l_base_pile_systeme)
4789: .niveau_courant =
4790: registre_niveau_courant;
4791: (*(*s_etat_processus).l_base_pile_systeme)
4792: .retour_definition =
4793: registre_retour_definition;
4794: }
4795: else
4796: {
4797: if ((*s_etat_processus).profilage == d_vrai)
4798: {
4799: profilage(s_etat_processus,
4800: (*(*s_etat_processus)
4801: .pointeur_variable_courante).nom);
4802:
4803: if ((*s_etat_processus).erreur_systeme
4804: != d_es)
4805: {
4806: return(d_erreur);
4807: }
4808: }
4809:
4810: empilement_pile_systeme(s_etat_processus);
4811: (*(*s_etat_processus).l_base_pile_systeme)
4812: .retour_definition = 'Y';
4813: (*(*s_etat_processus).l_base_pile_systeme)
4814: .niveau_courant = (*s_etat_processus)
4815: .niveau_courant;
4816: empilement_pile_systeme(s_etat_processus);
4817:
4818: if (evaluation(s_etat_processus,
4819: s_copie_variable_partagee,
4820: type_evaluation) == d_erreur)
4821: {
4822: depilement_pile_systeme(s_etat_processus);
4823: depilement_pile_systeme(s_etat_processus);
4824:
4825: liberation(s_etat_processus,
4826: s_copie_variable_partagee);
4827:
4828: if ((*s_etat_processus).profilage == d_vrai)
4829: {
4830: profilage(s_etat_processus, NULL);
4831: }
4832:
4833: (*s_etat_processus)
4834: .evaluation_expression_compilee =
4835: registre_evaluation_expression_compilee;
4836:
4837: if (presence_egalite == d_vrai)
4838: {
4839: liberation(s_etat_processus,
4840: s_objet_evalue);
4841: }
4842:
4843: (*s_etat_processus).instruction_courante =
4844: instruction_courante;
4845: (*s_etat_processus).mode_execution_programme
4846: = registre_mode_execution_programme;
4847: return(d_erreur);
4848: }
4849:
4850: depilement_pile_systeme(s_etat_processus);
4851: depilement_pile_systeme(s_etat_processus);
4852:
4853: liberation(s_etat_processus,
4854: s_copie_variable_partagee);
4855: }
4856:
4857: if ((*s_etat_processus).profilage == d_vrai)
4858: {
4859: profilage(s_etat_processus, NULL);
4860: }
4861:
4862: (*s_etat_processus)
4863: .evaluation_expression_compilee =
4864: registre_evaluation_expression_compilee;
4865: }
4866: }
4867: else
4868: {
4869: if (presence_variable_partagee == d_vrai)
4870: {
4871: liberation(s_etat_processus,
4872: s_copie_variable_partagee);
4873: }
4874:
4875: if ((s_objet_elementaire =
4876: copie_objet(s_etat_processus,
4877: (*l_element_courant).donnee, 'P')) == NULL)
4878: {
4879: if (presence_egalite == d_vrai)
4880: {
4881: liberation(s_etat_processus, s_objet_evalue);
4882: }
4883:
4884: (*s_etat_processus).erreur_systeme =
4885: d_es_allocation_memoire;
4886: (*s_etat_processus).instruction_courante =
4887: instruction_courante;
4888: return(d_erreur);
4889: }
4890:
4891: /*
4892: * Vérification du drapeau symbole pour
4893: * savoir si l'on met dans la pile le nom
4894: * ou le contenu de la variable.
4895: */
4896:
4897: if (((*((struct_nom *) (*s_objet_elementaire).objet))
4898: .symbole == d_faux) && ((*s_etat_processus)
4899: .traitement_symbolique == 'N'))
4900: {
4901: if (recherche_variable(s_etat_processus,
4902: (*((struct_nom *) (*s_objet_elementaire)
4903: .objet)).nom) == d_vrai)
4904: {
4905: if ((*(*s_etat_processus)
4906: .pointeur_variable_courante).objet
4907: == NULL)
4908: {
4909: // Variable partagée
4910:
4911: if (pthread_mutex_lock(
4912: &((*(*s_etat_processus)
4913: .s_liste_variables_partagees)
4914: .mutex)) != 0)
4915: {
4916: (*s_etat_processus).erreur_systeme =
4917: d_es_processus;
4918: return(d_erreur);
4919: }
4920:
4921: if (recherche_variable_partagee(
4922: s_etat_processus,
4923: (*(*s_etat_processus)
4924: .pointeur_variable_courante).nom,
4925: (*(*s_etat_processus)
4926: .pointeur_variable_courante)
4927: .variable_partagee, 'E') == d_vrai)
4928: {
4929: liberation(s_etat_processus,
4930: s_objet_elementaire);
4931:
4932: if ((s_objet_elementaire =
4933: copie_objet(s_etat_processus,
4934: (*(*s_etat_processus)
4935: .s_liste_variables_partagees)
4936: .table[(*(*s_etat_processus)
4937: .s_liste_variables_partagees)
4938: .position_variable].objet,
4939: 'P')) == NULL)
4940: {
4941: if (pthread_mutex_unlock(
4942: &((*(*s_etat_processus)
4943: .s_liste_variables_partagees
4944: ).mutex)) != 0)
4945: {
4946: (*s_etat_processus)
4947: .erreur_systeme =
4948: d_es_processus;
4949: return(d_erreur);
4950: }
4951:
4952: if (presence_egalite == d_vrai)
4953: {
4954: liberation(s_etat_processus,
4955: s_objet_evalue);
4956: }
4957:
4958: (*s_etat_processus).erreur_systeme =
4959: d_es_allocation_memoire;
4960: (*s_etat_processus)
4961: .instruction_courante =
4962: instruction_courante;
4963: return(d_erreur);
4964: }
4965: }
4966:
4967: if (pthread_mutex_unlock(
4968: &((*(*s_etat_processus)
4969: .s_liste_variables_partagees)
4970: .mutex)) != 0)
4971: {
4972: (*s_etat_processus).erreur_systeme =
4973: d_es_processus;
4974: return(d_erreur);
4975: }
4976: }
4977: else
4978: {
4979: // Variable privée
4980:
4981: liberation(s_etat_processus,
4982: s_objet_elementaire);
4983:
4984: if ((s_objet_elementaire =
4985: copie_objet(s_etat_processus,
4986: (*(*s_etat_processus)
4987: .pointeur_variable_courante).objet,
4988: 'P')) == NULL)
4989: {
4990: if (presence_egalite == d_vrai)
4991: {
4992: liberation(s_etat_processus,
4993: s_objet_evalue);
4994: }
4995:
4996: (*s_etat_processus).erreur_systeme =
4997: d_es_allocation_memoire;
4998: (*s_etat_processus)
4999: .instruction_courante =
5000: instruction_courante;
5001: return(d_erreur);
5002: }
5003: }
5004: }
5005: else
5006: {
5007: (*s_etat_processus).erreur_systeme = d_es;
5008:
5009: (*((struct_nom *) (*s_objet_elementaire)
5010: .objet)).symbole = d_vrai;
5011: }
5012: }
5013:
5014: if (empilement(s_etat_processus, &((*s_etat_processus)
5015: .l_base_pile), s_objet_elementaire) == d_erreur)
5016: {
5017: if (presence_egalite == d_vrai)
5018: {
5019: liberation(s_etat_processus, s_objet_evalue);
5020: }
5021:
5022: (*s_etat_processus).instruction_courante =
5023: instruction_courante;
5024: return(d_erreur);
5025: }
5026:
5027: if ((*s_etat_processus).erreur_execution ==
5028: d_ex_variable_non_definie)
5029: {
5030: (*s_etat_processus).erreur_execution = d_ex;
5031: }
5032: }
5033: }
5034: else
5035: {
5036: registre_type_evaluation = (test_cfsf(s_etat_processus, 35)
5037: == d_vrai) ? 'E' : 'N';
5038:
5039: if (type_evaluation == 'N')
5040: {
5041: cf(s_etat_processus, 35);
5042: }
5043: else
5044: {
5045: sf(s_etat_processus, 35);
5046: }
5047:
5048: analyse(s_etat_processus, NULL);
5049:
5050: if (registre_type_evaluation == 'E')
5051: {
5052: sf(s_etat_processus, 35);
5053: }
5054: else
5055: {
5056: cf(s_etat_processus, 35);
5057: }
5058:
5059: if (((*s_etat_processus).erreur_systeme != d_es) ||
5060: ((*s_etat_processus).erreur_execution != d_ex) ||
5061: ((*s_etat_processus).exception != d_ep))
5062: {
5063: // Il est anormal de récupérer ici une erreur
5064: // d'exécution puisqu'on empile une constante
5065: // symbolique.
5066:
5067: if (presence_egalite == d_vrai)
5068: {
5069: liberation(s_etat_processus, s_objet_evalue);
5070: }
5071:
5072: (*s_etat_processus).instruction_courante =
5073: instruction_courante;
5074: (*s_etat_processus).mode_execution_programme =
5075: registre_mode_execution_programme;
5076: return(d_erreur);
5077: }
5078: }
5079:
5080: (*s_etat_processus).instruction_courante =
5081: instruction_courante;
5082: (*s_etat_processus).test_instruction = registre_test;
5083: (*s_etat_processus).instruction_valide =
5084: registre_instruction_valide;
5085: }
5086: else
5087: {
5088: if ((s_objet_tampon = copie_objet(s_etat_processus,
5089: (*l_element_courant).donnee, 'P')) == NULL)
5090: {
5091: (*s_etat_processus).erreur_systeme =
5092: d_es_allocation_memoire;
5093: (*s_etat_processus).instruction_courante =
5094: instruction_courante;
5095: return(d_erreur);
5096: }
5097:
5098: if (empilement(s_etat_processus, &((*s_etat_processus)
5099: .l_base_pile), s_objet_tampon) == d_erreur)
5100: {
5101: if (presence_egalite == d_vrai)
5102: {
5103: liberation(s_etat_processus, s_objet_evalue);
5104: }
5105:
5106: (*s_etat_processus).instruction_courante =
5107: instruction_courante;
5108: return(d_erreur);
5109: }
5110: }
5111:
5112: // Traitement de l'instruction EXIT en mode interactif
5113:
5114: if (l_element_courant != NULL)
5115: {
5116: l_element_courant = (*l_element_courant).suivant;
5117: }
5118: else
5119: {
5120: (*s_etat_processus).mode_execution_programme = 'Y';
5121:
5122: if ((*s_etat_processus).niveau_courant == 1)
5123: {
5124: (*s_etat_processus).debug_programme = d_faux;
5125: (*s_etat_processus).execution_pas_suivant = d_vrai;
5126: }
5127: }
5128:
5129: if ((*s_etat_processus).traitement_cycle_exit != 'N')
5130: {
5131: registre_expression_courante =
5132: (*s_etat_processus).expression_courante;
5133: (*s_etat_processus).expression_courante =
5134: l_element_courant;
5135:
5136: switch((*s_etat_processus).traitement_cycle_exit)
5137: {
5138: case 'C' :
5139: {
5140: instruction_cycle(s_etat_processus);
5141: break;
5142: }
5143:
5144: case 'E' :
5145: {
5146: instruction_exit(s_etat_processus);
5147: break;
5148: }
5149: }
5150:
5151: l_element_courant = (*s_etat_processus).expression_courante;
5152: (*s_etat_processus).expression_courante =
5153: registre_expression_courante;
5154: }
5155: }
5156:
5157: if (niveau_initial < (*s_etat_processus).niveau_courant)
5158: {
5159: /*
5160: * Retrait des variables dans le cas où l'évaluation de
5161: * l'expression a été interrompue
5162: */
5163:
5164: (*s_etat_processus).niveau_courant = niveau_initial;
5165:
5166: if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
5167: {
5168: return(d_erreur);
5169: }
5170: }
5171:
5172: /*
5173: * Retrait des variables statiques créées dans l'expression
5174: */
5175:
5176: for(n = 0; n < (*s_etat_processus).nombre_variables_statiques; n++)
5177: {
5178: if ((*s_etat_processus).s_liste_variables_statiques[n]
5179: .niveau > (*s_etat_processus).niveau_courant)
5180: {
5181: if (retrait_variable_statique(s_etat_processus,
5182: (*s_etat_processus).s_liste_variables_statiques[n].nom,
5183: (*s_etat_processus).s_liste_variables_statiques[n]
5184: .variable_statique) == d_erreur)
5185: {
5186: if (presence_egalite == d_vrai)
5187: {
5188: liberation(s_etat_processus, s_objet_evalue);
5189: }
5190:
5191: (*s_etat_processus).instruction_courante =
5192: instruction_courante;
5193: (*s_etat_processus).mode_execution_programme =
5194: registre_mode_execution_programme;
5195: return(d_erreur);
5196: }
5197: }
5198: }
5199:
5200: /*
5201: * Retrait des variables partagées créées dans l'expression
5202: */
5203:
5204: if (pthread_mutex_lock(&((*(*s_etat_processus)
5205: .s_liste_variables_partagees).mutex)) != 0)
5206: {
5207: (*s_etat_processus).erreur_systeme = d_es_processus;
5208: return(d_erreur);
5209: }
5210:
5211: for(n = 0; n < (*(*s_etat_processus).s_liste_variables_partagees)
5212: .nombre_variables; n++)
5213: {
5214: if ((*(*s_etat_processus).s_liste_variables_partagees).table[n]
5215: .niveau > (*s_etat_processus).niveau_courant)
5216: {
5217: if (retrait_variable_partagee(s_etat_processus,
5218: (*(*s_etat_processus).s_liste_variables_partagees)
5219: .table[n].nom, (*(*s_etat_processus)
5220: .s_liste_variables_partagees).table[n]
5221: .variable_partagee) == d_erreur)
5222: {
5223: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5224: .s_liste_variables_partagees).mutex)) != 0)
5225: {
5226: (*s_etat_processus).erreur_systeme = d_es_processus;
5227: return(d_erreur);
5228: }
5229:
5230: if (presence_egalite == d_vrai)
5231: {
5232: liberation(s_etat_processus, s_objet_evalue);
5233: }
5234:
5235: (*s_etat_processus).instruction_courante =
5236: instruction_courante;
5237: (*s_etat_processus).mode_execution_programme =
5238: registre_mode_execution_programme;
5239: return(d_erreur);
5240: }
5241: }
5242: }
5243:
5244: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5245: .s_liste_variables_partagees).mutex)) != 0)
5246: {
5247: (*s_etat_processus).erreur_systeme = d_es_processus;
5248: return(d_erreur);
5249: }
5250:
5251: if ((*s_etat_processus).var_volatile_requete_arret != 0)
5252: {
5253: // Restauration de la pile système
5254:
5255: while(pile_systeme_originelle !=
5256: (*s_etat_processus).l_base_pile_systeme)
5257: {
5258: depilement_pile_systeme(s_etat_processus);
5259: }
5260: }
5261:
5262: if (presence_egalite == d_vrai)
5263: {
5264: // Ajout du membre évalué lors de la première passe
5265:
5266: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5267: s_objet_evalue) == d_erreur)
5268: {
5269: (*s_etat_processus).instruction_courante =
5270: instruction_courante;
5271: return(d_erreur);
5272: }
5273:
5274: instruction_swap(s_etat_processus);
5275:
5276: if ((*s_etat_processus).erreur_execution != d_ex)
5277: {
5278: (*s_etat_processus).mode_execution_programme =
5279: registre_mode_execution_programme;
5280: (*s_etat_processus).autorisation_empilement_programme =
5281: autorisation_empilement_programme;
5282: (*s_etat_processus).instruction_courante = instruction_courante;
5283: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5284: registre_retour_definition;
5285:
5286: return(d_erreur);
5287: }
5288:
5289: instruction_egalite(s_etat_processus);
5290:
5291: if ((*s_etat_processus).erreur_execution != d_ex)
5292: {
5293: (*s_etat_processus).mode_execution_programme =
5294: registre_mode_execution_programme;
5295: (*s_etat_processus).autorisation_empilement_programme =
5296: autorisation_empilement_programme;
5297: (*s_etat_processus).instruction_courante = instruction_courante;
5298: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5299: registre_retour_definition;
5300:
5301: return(d_erreur);
5302: }
5303: }
5304:
5305: (*s_etat_processus).autorisation_empilement_programme =
5306: autorisation_empilement_programme;
5307: (*s_etat_processus).instruction_courante = instruction_courante;
5308: (*(*s_etat_processus).l_base_pile_systeme).retour_definition =
5309: registre_retour_definition;
5310: }
5311: else if ((*s_objet).type == FCT)
5312: {
5313: (*s_etat_processus).instruction_courante =
5314: (*((struct_fonction *) (*s_objet).objet)).nom_fonction;
5315:
5316: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
5317: ? 'E' : 'N';
5318: cf(s_etat_processus, 35);
5319:
5320: analyse(s_etat_processus, (*((struct_fonction *)
5321: (*s_objet).objet)).fonction);
5322: (*s_etat_processus).instruction_courante = instruction_courante;
5323:
5324: if (registre_type_evaluation == 'E')
5325: {
5326: sf(s_etat_processus, 35);
5327: }
5328: else
5329: {
5330: cf(s_etat_processus, 35);
5331: }
5332:
5333: if (((*s_etat_processus).erreur_systeme != d_es) ||
5334: ((*s_etat_processus).erreur_execution != d_ex) ||
5335: ((*s_etat_processus).exception != d_ep))
5336: {
5337: (*s_etat_processus).mode_execution_programme =
5338: registre_mode_execution_programme;
5339: return(d_erreur);
5340: }
5341: }
5342: else
5343: {
5344: (*s_etat_processus).instruction_courante = instruction_courante;
5345:
5346: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P'))
5347: == NULL)
5348: {
5349: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5350: return(d_erreur);
5351: }
5352:
5353: if (empilement(s_etat_processus, &((*s_etat_processus)
5354: .l_base_pile), s_objet_tampon) == d_erreur)
5355: {
5356: return(d_erreur);
5357: }
5358: }
5359:
5360: (*s_etat_processus).mode_execution_programme =
5361: registre_mode_execution_programme;
5362:
5363: return((erreur_evaluation == d_absence_erreur)
5364: ? d_absence_erreur : d_erreur);
5365: }
5366:
5367: // vim: ts=4