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