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