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