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