1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.0.prerelease.0
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de création d'une nouvelle variable
29: Entrée : autorisation_creation_variable_statique vaut 'V' ou 'S'.
30: Dans le cas 'V', la variable est volatile.
31: Dans le cas 'S', elle est statique.
32: Entrée : autorisation_creation_variable_partagee vaut 'P' ou 'S'.
33: Dans le cas 'P', la variable est privée.
34: Dans le cas 'S', elle est partagée.
35: --------------------------------------------------------------------------------
36: Sortie :
37: --------------------------------------------------------------------------------
38: Effets de bords : néant
39: ================================================================================
40: */
41:
42: static logical1
43: ajout_variable(struct_processus *s_etat_processus, struct_variable *s_variable)
44: {
45: int i;
46:
47: struct_liste_variables *l_nouvelle_variable;
48: struct_liste_variables *l_variable_candidate;
49: struct_arbre_variables *l_variable_courante;
50: struct_arbre_variables *l_variable_precedente;
51:
52: struct_liste_chainee *l_nouvel_element;
53:
54: unsigned char *ptr;
55:
56: if ((*s_etat_processus).s_arbre_variables == NULL)
57: {
58: if (((*s_etat_processus).s_arbre_variables =
59: malloc(sizeof(struct_arbre_variables))) == NULL)
60: {
61: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
62: return(d_erreur);
63: }
64:
65: (*(*s_etat_processus).s_arbre_variables).feuille = NULL;
66: (*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
67: (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;
68:
69: if (((*(*s_etat_processus).arbre_instructions).noeud =
70: malloc((*s_etat_processus).nombre_caracteres_variables
71: * sizeof(struct_arbre_variables))) == NULL)
72: {
73: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
74: return(d_erreur);
75: }
76:
77: for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
78: {
79: (*(*s_etat_processus).s_arbre_variables).noeuds[i] = NULL;
80: }
81: }
82:
83: l_variable_precedente = NULL;
84: l_variable_courante = (*s_etat_processus).s_arbre_variables;
85: ptr = (*s_variable).nom;
86:
87: while((*ptr) != d_code_fin_chaine)
88: {
89: BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0,
90: printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom,
91: *ptr));
92:
93: if ((*l_variable_courante).noeuds[(*s_etat_processus)
94: .pointeurs_caracteres_variables[*ptr]] == NULL)
95: {
96: // Le noeud n'existe pas encore, on le crée.
97:
98: if (((*l_variable_courante).noeuds[(*s_etat_processus)
99: .pointeurs_caracteres_variables[*ptr]] =
100: malloc(sizeof(struct_arbre_variables))) == NULL)
101: {
102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
103: return(d_erreur);
104: }
105:
106: (*l_variable_courante).noeuds_utilises++;
107: (*(*l_variable_courante).noeuds[(*s_etat_processus)
108: .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
109: (*(*l_variable_courante).noeuds[(*s_etat_processus)
110: .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;
111: (*(*l_variable_courante).noeuds[(*s_etat_processus)
112: .pointeurs_caracteres_variables[*ptr]]).noeud_pere =
113: l_variable_precedente;
114:
115: if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
116: .pointeurs_caracteres_variables[*ptr]]).noeuds =
117: malloc((*s_etat_processus).nombre_caracteres_variables
118: * sizeof(struct_arbre_variables))) == NULL)
119: {
120: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
121: return(d_erreur);
122: }
123:
124: for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
125: {
126: (*(*l_variable_courante).noeuds[(*s_etat_processus)
127: .pointeurs_caracteres_variables[*ptr]]).noeuds[i]
128: = NULL;
129: }
130: }
131:
132: l_variable_precedente = l_variable_courante;
133: l_variable_courante = (*l_variable_courante).noeuds
134: [(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];
135: ptr++;
136: }
137:
138: if ((*l_variable_courante).feuille == NULL)
139: {
140: // Aucune variable de même nom préexiste. On alloue le premier
141: // élément de la liste doublement chaînée contenant toutes les
142: // variables de même nom. Cette liste boucle en premier lieu sur
143: // elle-même.
144:
145: if (((*l_variable_courante).feuille = malloc(
146: sizeof(struct_liste_variables))) == NULL)
147: {
148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
149: return(d_erreur);
150: }
151:
152: (*(*l_variable_courante).feuille).suivant =
153: (*l_variable_courante).feuille;
154: (*(*l_variable_courante).feuille).precedent =
155: (*l_variable_courante).feuille;
156: (*(*l_variable_courante).feuille).noeud_pere = l_variable_precedente;
157:
158: // Allocation de la variable sur l'élément de la liste.
159:
160: if (((*(*l_variable_courante).feuille).variable =
161: malloc(sizeof(struct_variable))) == NULL)
162: {
163: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
164: return(d_erreur);
165: }
166:
167: (*((struct_variable *) (*(*l_variable_courante).feuille).variable)) =
168: (*s_variable);
169:
170: if (((*((struct_variable *) (*(*l_variable_courante).feuille).variable))
171: .nom = strdup((*s_variable).nom)) == NULL)
172: {
173: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
174: return(d_erreur);
175: }
176: }
177: else
178: {
179: if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
180: == NULL)
181: {
182: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
183: return(d_erreur);
184: }
185:
186: if ((*s_variable).niveau > 1)
187: {
188: // Cas d'une variable locale
189:
190: // Si le niveau de la dernière variable de même nom est
191: // supérieur au niveau de la variable locale que l'on veut
192: // enregistrer dans la liste, cette liste est incohérente.
193:
194: BUG((*(*(*l_variable_courante).feuille).variable).niveau >=
195: (*s_variable).niveau,
196: printf("Variable=\"%s\"\n", (*s_variable).nom));
197:
198: // On ajoute la variable à la liste existante.
199:
200: (*l_nouvelle_variable).suivant = (*l_variable_courante).feuille;
201: (*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille)
202: .precedent;
203: (*l_nouvelle_variable).noeud_pere = l_variable_precedente;
204: (*(*(*l_variable_courante).feuille).precedent).suivant =
205: l_nouvelle_variable;
206: (*(*l_variable_courante).feuille).precedent =
207: l_nouvelle_variable;
208: (*l_variable_courante).feuille = l_nouvelle_variable;
209:
210: if (((*(*l_variable_courante).feuille).variable =
211: malloc(sizeof(struct_variable))) == NULL)
212: {
213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
214: return(d_erreur);
215: }
216:
217: (*((struct_variable *) (*(*l_variable_courante).feuille).variable))
218: = (*s_variable);
219:
220: if (((*((struct_variable *) (*(*l_variable_courante).feuille)
221: .variable)).nom = strdup((*s_variable).nom)) == NULL)
222: {
223: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
224: return(d_erreur);
225: }
226: }
227: else
228: {
229: // Cas d'une variable globale (niveau 0 [définitions] ou 1
230: // [variables globales])
231:
232: l_variable_candidate = (*l_variable_courante).feuille;
233:
234: do
235: {
236: // S'il y a déjà une variable de même niveau, la pile
237: // est incohérente.
238:
239: BUG((*(*l_variable_candidate).variable).niveau ==
240: (*s_variable).niveau,
241: printf("Variable=\"%s\"\n", (*s_variable).nom));
242:
243: l_variable_candidate = (*l_variable_candidate).precedent;
244: } while((l_variable_candidate != (*l_variable_courante).feuille) &&
245: ((*(*l_variable_candidate).variable).niveau <= 1));
246:
247: if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
248: .niveau > 1)
249: {
250: // Ajout inconditionnel des variables de niveaux 0 et 1
251: }
252: else
253: {
254: l_variable_candidate = (*(*l_variable_courante).feuille)
255: .precedent;
256: }
257:
258: (*l_nouvelle_variable).suivant = l_variable_candidate;
259: (*l_nouvelle_variable).precedent = (*l_variable_candidate)
260: .precedent;
261: (*l_nouvelle_variable).noeud_pere = l_variable_precedente;
262: (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
263: (*l_variable_candidate).precedent = l_nouvelle_variable;
264:
265: if (((*l_nouvelle_variable).variable =
266: malloc(sizeof(struct_variable))) == NULL)
267: {
268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
269: return(d_erreur);
270: }
271:
272: (*(*l_nouvelle_variable).variable) = (*s_variable);
273:
274: if (((*(*l_nouvelle_variable).variable).nom =
275: strdup((*s_variable).nom)) == NULL)
276: {
277: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
278: return(d_erreur);
279: }
280: }
281: }
282:
283: // Ajout de la variable nouvellement créée à la liste par niveaux.
284: // Le pointeur contenu dans la structure de description du processus indique
285: // toujours le plus haut niveau utilisé.
286:
287: if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
288: {
289: // Le niveau courant n'existe pas. Il est créé.
290:
291: if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
292: == NULL)
293: {
294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
295: return(d_erreur);
296: }
297:
298: (*l_nouvelle_variable).suivant = l_nouvelle_variable;
299: (*l_nouvelle_variable).precedent = l_nouvelle_variable;
300: (*l_nouvelle_variable).noeud_pere = NULL;
301:
302: (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
303: }
304: else if ((*s_variable).niveau > (*((struct_variable *)
305: (*(*(*s_etat_processus).l_liste_variables_par_niveau).liste)
306: .donnee)).niveau)
307: {
308: // Le niveau courant n'existe pas. Il est créé.
309:
310: if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
311: == NULL)
312: {
313: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
314: return(d_erreur);
315: }
316:
317: (*l_nouvelle_variable).suivant = (*s_etat_processus)
318: .l_liste_variables_par_niveau;
319: (*l_nouvelle_variable).precedent = (*(*s_etat_processus)
320: .l_liste_variables_par_niveau).precedent;
321: (*l_nouvelle_variable).noeud_pere = NULL;
322: (*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent)
323: .suivant = l_nouvelle_variable;
324: (*(*s_etat_processus).l_liste_variables_par_niveau).precedent =
325: l_nouvelle_variable;
326:
327: (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
328: }
329: else
330: {
331: // Création d'une variable de niveau 0 ou 1
332:
333: if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
334: == NULL)
335: {
336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
337: return(d_erreur);
338: }
339:
340: l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;
341:
342: if ((*((struct_variable *) (*(*(*(*s_etat_processus)
343: .l_liste_variables_par_niveau).precedent).liste).donnee))
344: .niveau > 1)
345: {
346: // Ajout inconditionnel des variables de niveaux 0 et 1
347: }
348: else
349: {
350: l_variable_candidate = (*(*s_etat_processus)
351: .l_liste_variables_par_niveau).precedent;
352: }
353:
354: (*l_nouvelle_variable).suivant = l_variable_candidate;
355: (*l_nouvelle_variable).precedent = (*l_variable_candidate)
356: .precedent;
357: (*l_nouvelle_variable).noeud_pere = NULL;
358: (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
359: (*l_variable_candidate).precedent = l_nouvelle_variable;
360: }
361:
362: // Ajout de la variable en tête de la liste
363:
364: if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
365: {
366: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
367: return(d_erreur);
368: }
369:
370: (*l_nouvel_element).suivant = (*(*s_etat_processus)
371: .l_liste_variables_par_niveau).liste;
372: (*l_nouvel_element).donnee = (struct_objet *) s_variable;
373: (*l_nouvelle_variable).liste = l_nouvel_element;
374:
375: return(d_absence_erreur);
376: }
377:
378: logical1
379: creation_variable(struct_processus *s_etat_processus,
380: struct_variable *s_variable,
381: unsigned char autorisation_creation_variable_statique,
382: unsigned char autorisation_creation_variable_partagee)
383: {
384: if ((*s_etat_processus).mode_execution_programme == 'Y')
385: {
386: (*s_variable).origine = 'P';
387: }
388: else
389: {
390: (*s_variable).origine = 'E';
391: }
392:
393: if ((*s_variable).niveau == 0)
394: {
395: // Un point d'entrée de définition est verrouillé.
396:
397: if ((*s_variable).origine == 'P')
398: {
399: (*s_variable).variable_statique.adresse = 0;
400: (*s_variable).variable_partagee.adresse = 0;
401: }
402: else
403: {
404: (*s_variable).variable_statique.pointeur = NULL;
405: (*s_variable).variable_partagee.pointeur = NULL;
406: }
407:
408: (*s_variable).variable_verrouillee = d_vrai;
409: }
410: else if ((*s_variable).niveau == 1)
411: {
412: // Une variable globale ne peut être statique.
413:
414: if ((*s_variable).origine == 'P')
415: {
416: (*s_variable).variable_statique.adresse = 0;
417: (*s_variable).variable_partagee.adresse = 0;
418: }
419: else
420: {
421: (*s_variable).variable_statique.pointeur = NULL;
422: (*s_variable).variable_partagee.pointeur = NULL;
423: }
424:
425: (*s_variable).variable_verrouillee = d_faux;
426: }
427: else
428: {
429: // 0 -> variable volatile
430: // adresse de création -> variable statique
431:
432: if (autorisation_creation_variable_statique == 'V')
433: {
434: if (autorisation_creation_variable_partagee == 'S')
435: {
436: // On force la création d'une variable partagée
437:
438: if ((*s_variable).origine == 'P')
439: {
440: (*s_variable).variable_statique.adresse = 0;
441: (*s_variable).variable_partagee.adresse =
442: (*s_etat_processus).position_courante;
443: }
444: else
445: {
446: (*s_variable).variable_statique.pointeur = NULL;
447: (*s_variable).variable_partagee.pointeur =
448: (*s_etat_processus).objet_courant;
449: }
450: }
451: else
452: {
453: // On force la création d'une variable volatile
454:
455: if ((*s_variable).origine == 'P')
456: {
457: (*s_variable).variable_statique.adresse = 0;
458: (*s_variable).variable_partagee.adresse = 0;
459: }
460: else
461: {
462: (*s_variable).variable_statique.pointeur = NULL;
463: (*s_variable).variable_partagee.pointeur = NULL;
464: }
465: }
466: }
467: else
468: {
469: // On force la création d'une variable statique.
470:
471: if ((*s_variable).origine == 'P')
472: {
473: (*s_variable).variable_statique.adresse =
474: (*s_etat_processus).position_courante;
475: (*s_variable).variable_partagee.adresse = 0;
476: }
477: else
478: {
479: (*s_variable).variable_statique.pointeur =
480: (*s_etat_processus).objet_courant;
481: (*s_variable).variable_partagee.pointeur = 0;
482: }
483: }
484:
485: (*s_variable).variable_verrouillee = d_faux;
486: }
487:
488: /*
489: * Recherche de la feuille correspondante dans l'arbre des variables.
490: * Si cette feuille n'existe pas, elle est créée.
491: */
492:
493: if (ajout_variable(s_etat_processus, s_variable) == d_erreur)
494: {
495: return(d_erreur);
496: }
497:
498: return(d_absence_erreur);
499: }
500:
501:
502: /*
503: ================================================================================
504: Procédure de recherche d'une variable par son nom dans la base
505: ================================================================================
506: Entrée :
507: --------------------------------------------------------------------------------
508: Sortie :
509: --------------------------------------------------------------------------------
510: Effets de bord : néant
511: ================================================================================
512: */
513:
514: logical1
515: recherche_variable(struct_processus *s_etat_processus,
516: unsigned char *nom_variable)
517: {
518: int pointeur;
519:
520: struct_arbre_variables *l_variable_courante;
521: struct_liste_pile_systeme *l_element_courant;
522:
523: unsigned char *ptr;
524:
525: unsigned long niveau_appel;
526:
527: if ((*s_etat_processus).s_arbre_variables == NULL)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
530: return d_faux;
531: }
532:
533: l_variable_courante = (*s_etat_processus).s_arbre_variables;
534: ptr = nom_variable;
535:
536: while((*ptr) != d_code_fin_chaine)
537: {
538: pointeur = (*s_etat_processus).pointeurs_caracteres_variables[*ptr];
539:
540: if (pointeur < 0)
541: {
542: // Caractère hors de l'alphabet des variables
543: return(d_erreur);
544: }
545:
546: if ((*l_variable_courante).noeuds[pointeur] == NULL)
547: {
548: // Le chemin de la variable candidate n'existe pas.
549: return(d_erreur);
550: }
551:
552: l_variable_courante = (*l_variable_courante).noeuds[pointeur];
553: ptr++;
554: }
555:
556: if ((*l_variable_courante).feuille != NULL)
557: {
558: // Il existe une pile de variables de même nom. Le sommet de la
559: // pile est la variable de niveau le plus haut.
560:
561: l_element_courant = (*s_etat_processus).l_base_pile_systeme;
562:
563: if (l_element_courant == NULL)
564: {
565: // Problème : la pile système est vide !
566: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
567: return(d_erreur);
568: }
569:
570: while((*l_element_courant).retour_definition != 'Y')
571: {
572: l_element_courant = (*l_element_courant).suivant;
573:
574: if (l_element_courant == NULL)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
577: return(d_erreur);
578: }
579: }
580:
581: niveau_appel = (*l_element_courant).niveau_courant;
582:
583: if (niveau_appel < (*(*(*l_variable_courante).feuille).variable).niveau)
584: {
585: // Une variable locale est accessible puisque créée dans la
586: // fonction courante.
587:
588: (*s_etat_processus).pointeur_variable_courante =
589: (*(*l_variable_courante).feuille).variable;
590: (*s_etat_processus).pointeur_feuille_courante =
591: (*l_variable_courante).feuille;
592: return(d_absence_erreur);
593: }
594: else
595: {
596: // Aucune variable locale n'est accessible depuis la fonction.
597: // Dans ce cas, on prend la variable de niveau le plus bas
598: // si ce niveau est inférieur ou égal à 1 (variable globale
599: // ou fonction définie par l'utilisateur). Si le niveau de la
600: // plus ancienne variable est strictement supérieur à 1, il
601: // s'agit d'une variable locale inaccessible.
602:
603: if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
604: .niveau <= 1)
605: {
606: (*s_etat_processus).pointeur_variable_courante =
607: (*(*(*l_variable_courante).feuille).precedent).variable;
608: (*s_etat_processus).pointeur_feuille_courante =
609: (*l_variable_courante).feuille;
610:
611: // S'il existe une variable de niveau 0 et une seconde de
612: // niveau 1, la variable de niveau 0 (fonction) est masquée
613: // par celle de niveau 1.
614:
615: if (((*(*(*l_variable_courante).feuille).variable).niveau == 0)
616: && ((*(*(*(*l_variable_courante).feuille).precedent)
617: .variable).niveau == 1))
618: {
619: (*s_etat_processus).pointeur_variable_courante =
620: (*(*(*l_variable_courante).feuille).precedent)
621: .variable;
622: (*s_etat_processus).pointeur_feuille_courante =
623: (*l_variable_courante).feuille;
624: }
625:
626: return(d_absence_erreur);
627: }
628: }
629: }
630:
631: return(d_erreur);
632: }
633:
634:
635: /*
636: ================================================================================
637: Procédure de retrait d'une variable de la base
638: ================================================================================
639: Entrée : type 'G' ou 'L' selon que l'on retire une variable locale (incluant
640: les globales) ou strictement globale.
641: --------------------------------------------------------------------------------
642: Sortie :
643: --------------------------------------------------------------------------------
644: Effets de bord : néant
645: ================================================================================
646: */
647:
648: logical1
649: retrait_variable(struct_processus *s_etat_processus,
650: unsigned char *nom_variable, unsigned char type)
651: {
652: logical1 erreur;
653:
654: struct_arbre_variables *s_arbre_a_supprimer;
655: struct_arbre_variables *s_arbre_courant;
656:
657: struct_liste_chainee *l_element_courant;
658: struct_liste_chainee *l_element_precedent;
659:
660: struct_liste_variables *variable_a_supprimer;
661: struct_liste_variables *variables_par_niveau;
662:
663: unsigned long niveau;
664:
665: if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)
666: {
667: // Une variable correspondant au nom recherché est accessible.
668:
669: if (type == 'G')
670: {
671: if ((*(*s_etat_processus).pointeur_variable_courante).niveau > 1)
672: {
673: // La variable obtenue est une variable locale. il faut
674: // s'assurer qu'il existe une variable de niveau 1 de même
675: // nom sur la feuille.
676:
677: if ((*(*(*(*s_etat_processus).pointeur_feuille_courante)
678: .precedent).variable).niveau <= 1)
679: {
680: (*s_etat_processus).pointeur_feuille_courante =
681: (*(*s_etat_processus).pointeur_feuille_courante)
682: .precedent;
683: (*s_etat_processus).pointeur_variable_courante =
684: (*(*s_etat_processus).pointeur_feuille_courante)
685: .variable;
686:
687: // Si la variable retournée est de niveau 0, on regarde
688: // un peu plus loin si une variable de niveau 1 existe.
689:
690: if (((*(*(*s_etat_processus).pointeur_feuille_courante)
691: .variable).niveau == 0) &&
692: ((*(*(*(*s_etat_processus)
693: .pointeur_feuille_courante).precedent).variable)
694: .niveau == 1))
695: {
696: (*s_etat_processus).pointeur_feuille_courante =
697: (*(*s_etat_processus).pointeur_feuille_courante)
698: .precedent;
699: (*s_etat_processus).pointeur_variable_courante =
700: (*(*s_etat_processus).pointeur_feuille_courante)
701: .variable;
702: }
703: }
704: else
705: {
706: // Aucune variable globale (niveau 1) n'existe.
707:
708: erreur = d_erreur;
709: (*s_etat_processus).erreur_execution =
710: d_ex_variable_non_definie;
711: return(erreur);
712: }
713: }
714:
715: if ((*(*s_etat_processus).pointeur_variable_courante)
716: .variable_verrouillee == d_vrai)
717: {
718: erreur = d_erreur;
719: (*s_etat_processus).erreur_execution =
720: d_ex_variable_verrouillee;
721: return(erreur);
722: }
723: }
724:
725: // Suppression de la variable de la liste.
726: // Deux cas peuvent survenir :
727: // 1/ les pointeurs sur la variable et la variable suivante
728: // sont identiques et on supprime la variable ainsi que la feuille
729: // associée ;
730: // 2/ ces deux pointeurs sont différents et se contente de retirer
731: // la structure décrivant la variable.
732:
733: if ((*s_etat_processus).pointeur_feuille_courante ==
734: (*(*s_etat_processus).pointeur_feuille_courante).suivant)
735: {
736: // Cas 1 :
737: // On retire la variable du noeud en décrémentant le nombre
738: // de feuilles de ce noeud. Si le nombre de feuilles du noeud
739: // est nul, on retire les noeuds récursivement jusqu'à obtenir
740: // un nombre non nul de feuilles utilisées (ou la racine des
741: // variables).
742:
743: variable_a_supprimer = (*s_etat_processus)
744: .pointeur_feuille_courante;
745: s_arbre_courant = (*variable_a_supprimer).noeud_pere;
746:
747: BUG((*s_arbre_courant).noeuds_utilises == 0,
748: uprintf("Freed node !\n"));
749: (*s_arbre_courant).noeuds_utilises--;
750:
751: while((*s_arbre_courant).noeuds_utilises == 0)
752: {
753: s_arbre_a_supprimer = s_arbre_courant;
754: s_arbre_courant = (*s_arbre_courant).noeud_pere;
755:
756: free((*s_arbre_a_supprimer).noeuds);
757: free(s_arbre_a_supprimer);
758:
759: if (s_arbre_courant == NULL)
760: {
761: break;
762: }
763:
764: BUG((*s_arbre_courant).noeuds_utilises == 0,
765: uprintf("Freed node !\n"));
766: (*s_arbre_courant).noeuds_utilises--;
767: }
768: }
769: else
770: {
771: // Cas 2 :
772: // On retire la variable de la liste.
773:
774: variable_a_supprimer = (*s_etat_processus)
775: .pointeur_feuille_courante;
776:
777: (*(*(*s_etat_processus).pointeur_feuille_courante).precedent)
778: .suivant = (*(*s_etat_processus).pointeur_feuille_courante)
779: .suivant;
780: (*(*(*s_etat_processus).pointeur_feuille_courante).suivant)
781: .precedent = (*(*s_etat_processus)
782: .pointeur_feuille_courante).precedent;
783: }
784:
785: // Dans tous les cas, on retire la variable de la liste des variables
786: // par niveau.
787:
788: niveau = (*(*variable_a_supprimer).variable).niveau;
789: variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;
790:
791: while(variables_par_niveau != NULL)
792: {
793: l_element_courant = (*variables_par_niveau).liste;
794:
795: if (l_element_courant != NULL)
796: {
797: if ((*((struct_variable *) (*l_element_courant).donnee)).niveau
798: == niveau)
799: {
800: // On parcourt le bon niveau.
801:
802: l_element_precedent = NULL;
803:
804: while(l_element_courant != NULL)
805: {
806: // Tant que l_element_courant est non nul, il reste des
807: // variables à explorer dans le niveau courant.
808:
809: if ((*l_element_courant).donnee ==
810: (void *) (*variable_a_supprimer).variable)
811: {
812: // On a trouvé la variable à supprimer.
813:
814: if (l_element_precedent == NULL)
815: {
816: (*variables_par_niveau).liste =
817: (*l_element_courant).suivant;
818: }
819: else
820: {
821: (*l_element_precedent).suivant =
822: (*l_element_courant).suivant;
823: }
824: }
825:
826: l_element_precedent = l_element_courant;
827: l_element_courant = (*l_element_courant).suivant;
828: }
829: }
830: }
831:
832: variables_par_niveau = (*variables_par_niveau).suivant;
833: }
834:
835: // Puis on libère le contenu de la variable.
836:
837: free((*(*variable_a_supprimer).variable).nom);
838: liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet);
839:
840: erreur = d_absence_erreur;
841: }
842: else
843: {
844: // Aucune variable n'est accessible depuis le point courant du
845: // programme.
846:
847: erreur = d_erreur;
848: (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
849: }
850:
851: return(erreur);
852: }
853:
854:
855: /*
856: ================================================================================
857: Procédure de retrait des variables de niveau strictement supérieur au
858: niveau courant
859: ================================================================================
860: Entrée :
861: --------------------------------------------------------------------------------
862: Sortie :
863: --------------------------------------------------------------------------------
864: Effets de bord : néant
865: ================================================================================
866: */
867:
868: logical1
869: retrait_variable_par_niveau(struct_processus *s_etat_processus)
870: {
871: // Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.
872: // La tête de la pile contient toujours les variables de plus haut niveau
873: // créées.
874:
875: struct_liste_variables *l_niveau_suivant;
876:
877: while((*s_etat_processus).l_liste_variables_par_niveau != NULL)
878: {
879: l_niveau_suivant = (*(*s_etat_processus).l_liste_variables_par_niveau)
880: .suivant;
881:
882: if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL)
883: {
884: // Si le niveau ne contient aucune variable, on le détruit.
885: // Le pointeur sur la chaîne est déjà nul et il ne reste rien à
886: // faire.
887: }
888: else
889: {
890: // Le niveau contient des variables.
891:
892: if ((*((struct_variable *) (*(*(*s_etat_processus)
893: .l_liste_variables_par_niveau).liste).donnee)).niveau
894: <= (*s_etat_processus).niveau_courant)
895: {
896: // On a retiré de l'arbre des variables toutes les
897: // variables de niveau strictement supérieur au niveau
898: // courant.
899:
900: break;
901: }
902:
903: while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
904: != NULL)
905: {
906: // Sauvegarde des variables statiques.
907:
908: if ((*((struct_variable *) (*(*(*s_etat_processus)
909: .l_liste_variables_par_niveau).liste).donnee)).origine
910: == 'P')
911: {
912: if ((*((struct_variable *) (*(*(*s_etat_processus)
913: .l_liste_variables_par_niveau).liste).donnee))
914: .variable_statique.adresse != 0)
915: {
916: if (recherche_variable_statique(s_etat_processus,
917: (*((struct_variable *) (*(*(*s_etat_processus)
918: .l_liste_variables_par_niveau).liste).donnee))
919: .nom, (*((struct_variable *)
920: (*(*(*s_etat_processus)
921: .l_liste_variables_par_niveau).liste).donnee))
922: .variable_statique, ((*s_etat_processus)
923: .mode_execution_programme
924: == 'Y') ? 'P' : 'E') == d_vrai)
925: {
926: (*s_etat_processus).s_liste_variables_statiques
927: [(*s_etat_processus)
928: .position_variable_statique_courante]
929: .objet = (*((struct_variable *)
930: (*(*(*s_etat_processus)
931: .l_liste_variables_par_niveau).liste)
932: .donnee)).objet;
933: }
934: else
935: {
936: (*s_etat_processus).erreur_systeme =
937: d_es_variable_introuvable;
938: }
939:
940: (*((struct_variable *) (*(*(*s_etat_processus)
941: .l_liste_variables_par_niveau).liste).donnee))
942: .objet = NULL;
943: }
944: }
945: else
946: {
947: if ((*((struct_variable *) (*(*(*s_etat_processus)
948: .l_liste_variables_par_niveau).liste).donnee))
949: .variable_statique.pointeur != NULL)
950: {
951: /*
952: * Gestion des variables statiques
953: */
954:
955: if (recherche_variable_statique(s_etat_processus,
956: (*((struct_variable *) (*(*(*s_etat_processus)
957: .l_liste_variables_par_niveau).liste).donnee))
958: .nom, (*((struct_variable *)
959: (*(*(*s_etat_processus)
960: .l_liste_variables_par_niveau).liste).donnee))
961: .variable_statique, ((*s_etat_processus)
962: .mode_execution_programme
963: == 'Y') ? 'P' : 'E') == d_vrai)
964: {
965: (*s_etat_processus).s_liste_variables_statiques
966: [(*s_etat_processus)
967: .position_variable_statique_courante]
968: .objet = (*((struct_variable *)
969: (*(*(*s_etat_processus)
970: .l_liste_variables_par_niveau).liste)
971: .donnee)).objet;
972: }
973: else
974: {
975: (*s_etat_processus).erreur_systeme =
976: d_es_variable_introuvable;
977: return(d_erreur);
978: }
979:
980: (*((struct_variable *) (*(*(*s_etat_processus)
981: .l_liste_variables_par_niveau).liste).donnee))
982: .objet = NULL;
983: }
984: }
985:
986: if (retrait_variable(s_etat_processus,
987: (*((struct_variable *) (*(*(*s_etat_processus)
988: .l_liste_variables_par_niveau).liste).donnee)).nom,
989: 'L') == d_erreur)
990: {
991: return(d_erreur);
992: }
993: }
994: }
995:
996: free((*s_etat_processus).l_liste_variables_par_niveau);
997: (*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;
998: }
999:
1000: return(d_absence_erreur);
1001: }
1002:
1003:
1004: /*
1005: ================================================================================
1006: Procédure de retrait des toutes les variables locales et globales
1007: ================================================================================
1008: Entrée : drapeau indiquant s'il faut retirer les définitions (variables
1009: de niveau 0)
1010: --------------------------------------------------------------------------------
1011: Sortie :
1012: --------------------------------------------------------------------------------
1013: Effets de bord : néant
1014: ================================================================================
1015: */
1016:
1017: void
1018: liberation_arbre_variables(struct_processus *s_etat_processus,
1019: struct_arbre_variables *arbre, logical1 retrait_definitions)
1020: {
1021: int i;
1022:
1023: struct_liste_chainee *l_element_courant_liste;
1024: struct_liste_chainee *l_element_suivant_liste;
1025:
1026: struct_liste_variables *l_element_courant;
1027: struct_liste_variables *l_element_suivant;
1028:
1029: // Libération de l'arbre des variables. Le contenu des variables n'est
1030: // pas détruit par cette opération, il sera détruit lors de la libération
1031: // de la liste des variables par niveau.
1032:
1033: for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
1034: {
1035: if ((*arbre).noeuds[i] != NULL)
1036: {
1037: l_element_courant = (*arbre).feuille;
1038:
1039: while(l_element_courant != NULL)
1040: {
1041: l_element_suivant = (*l_element_courant).suivant;
1042: free(l_element_courant);
1043: l_element_courant = l_element_suivant;
1044: }
1045:
1046: liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
1047: retrait_definitions);
1048: }
1049: }
1050:
1051: // Suppression de la liste des variables par niveau.
1052:
1053: if (arbre == (*s_etat_processus).s_arbre_variables)
1054: {
1055: l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;
1056:
1057: while(l_element_courant != NULL)
1058: {
1059: l_element_courant_liste = (*l_element_courant).liste;
1060:
1061: while(l_element_courant_liste != NULL)
1062: {
1063: if ((retrait_definitions == d_vrai) ||
1064: ((*((struct_variable *) (*l_element_courant_liste)
1065: .donnee)).niveau >= 1))
1066: {
1067: liberation(s_etat_processus, (*((struct_variable *)
1068: (*l_element_courant_liste).donnee)).objet);
1069: free((*((struct_variable *) (*l_element_courant_liste)
1070: .donnee)).nom);
1071: free((*l_element_courant_liste).donnee);
1072: }
1073:
1074: l_element_suivant_liste = (*l_element_courant_liste).suivant;
1075: free(l_element_courant_liste);
1076: l_element_courant_liste = l_element_suivant_liste;
1077: }
1078:
1079: l_element_suivant = (*l_element_courant).suivant;
1080: free(l_element_courant);
1081: l_element_courant = l_element_suivant;
1082: }
1083: }
1084:
1085: free((*arbre).noeuds);
1086: free(arbre);
1087:
1088: return;
1089: }
1090:
1091:
1092: /*
1093: ================================================================================
1094: Procédure de copie de l'arbre des variables
1095: ================================================================================
1096: Entrée :
1097: --------------------------------------------------------------------------------
1098: Sortie :
1099: --------------------------------------------------------------------------------
1100: Effets de bord : néant
1101: ================================================================================
1102: */
1103:
1104: struct_arbre_variables *
1105: copie_arbre_variables(struct_processus *s_etat_processus)
1106: {
1107: // Les définitions sont partagées entre tous les threads et ne sont pas
1108: // copiées.
1109: //
1110: // NB : on ne copie que les variables de niveaux 0 et 1, les autres
1111: // variables locales étant masquées par le processus de création de thread
1112: // ou de processus, elles sont inaccessibles.
1113:
1114: BUG(1, uprintf("Oops !\n"));
1115:
1116: return(d_absence_erreur);
1117: }
1118:
1119:
1120: /*
1121: ================================================================================
1122: Procédure d'initialisation de la table de correspondance des variables
1123: ================================================================================
1124: Entrée :
1125: --------------------------------------------------------------------------------
1126: Sortie :
1127: --------------------------------------------------------------------------------
1128: Effets de bord : néant
1129: ================================================================================
1130: */
1131:
1132: /*
1133: * Caractères autorisés dans les instructions
1134: *
1135: * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
1136: * a b c d e f g h i j k l m n o p q r s t u v w x y z
1137: * _
1138: * 1 2 3 4 5 6 7 8 9 0
1139: */
1140:
1141: void
1142: initialisation_variables(struct_processus *s_etat_processus)
1143: {
1144: int decalage;
1145: int i;
1146: int longueur_tableau;
1147:
1148: unsigned char caractere;
1149:
1150: // Récupération de la longueur d'un unsigned char
1151:
1152: longueur_tableau = 1;
1153: decalage = 0;
1154: caractere = 1;
1155:
1156: while((1L << decalage) == (long) ((unsigned char) (caractere << decalage)))
1157: {
1158: decalage++;
1159: longueur_tableau *= 2;
1160: }
1161:
1162: if (((*s_etat_processus).pointeurs_caracteres_variables =
1163: malloc(longueur_tableau * sizeof(int))) == NULL)
1164: {
1165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1166: return;
1167: }
1168:
1169: for(i = 0; i < longueur_tableau; i++)
1170: {
1171: (*s_etat_processus).pointeurs_caracteres_variables[i] = -1;
1172: }
1173:
1174: (*s_etat_processus).nombre_caracteres_variables = 0;
1175:
1176: #define DECLARATION_CARACTERE(c) \
1177: do { (*s_etat_processus).pointeurs_caracteres_variables[c] = \
1178: (*s_etat_processus).nombre_caracteres_variables++; } while(0)
1179:
1180: DECLARATION_CARACTERE('A');
1181: DECLARATION_CARACTERE('B');
1182: DECLARATION_CARACTERE('C');
1183: DECLARATION_CARACTERE('D');
1184: DECLARATION_CARACTERE('E');
1185: DECLARATION_CARACTERE('F');
1186: DECLARATION_CARACTERE('G');
1187: DECLARATION_CARACTERE('H');
1188: DECLARATION_CARACTERE('I');
1189: DECLARATION_CARACTERE('J');
1190: DECLARATION_CARACTERE('K');
1191: DECLARATION_CARACTERE('L');
1192: DECLARATION_CARACTERE('M');
1193: DECLARATION_CARACTERE('N');
1194: DECLARATION_CARACTERE('O');
1195: DECLARATION_CARACTERE('P');
1196: DECLARATION_CARACTERE('Q');
1197: DECLARATION_CARACTERE('R');
1198: DECLARATION_CARACTERE('S');
1199: DECLARATION_CARACTERE('T');
1200: DECLARATION_CARACTERE('U');
1201: DECLARATION_CARACTERE('V');
1202: DECLARATION_CARACTERE('W');
1203: DECLARATION_CARACTERE('X');
1204: DECLARATION_CARACTERE('Y');
1205: DECLARATION_CARACTERE('Z');
1206:
1207: DECLARATION_CARACTERE('a');
1208: DECLARATION_CARACTERE('b');
1209: DECLARATION_CARACTERE('c');
1210: DECLARATION_CARACTERE('d');
1211: DECLARATION_CARACTERE('e');
1212: DECLARATION_CARACTERE('f');
1213: DECLARATION_CARACTERE('g');
1214: DECLARATION_CARACTERE('h');
1215: DECLARATION_CARACTERE('i');
1216: DECLARATION_CARACTERE('j');
1217: DECLARATION_CARACTERE('k');
1218: DECLARATION_CARACTERE('l');
1219: DECLARATION_CARACTERE('m');
1220: DECLARATION_CARACTERE('n');
1221: DECLARATION_CARACTERE('o');
1222: DECLARATION_CARACTERE('p');
1223: DECLARATION_CARACTERE('q');
1224: DECLARATION_CARACTERE('r');
1225: DECLARATION_CARACTERE('s');
1226: DECLARATION_CARACTERE('t');
1227: DECLARATION_CARACTERE('u');
1228: DECLARATION_CARACTERE('v');
1229: DECLARATION_CARACTERE('w');
1230: DECLARATION_CARACTERE('x');
1231: DECLARATION_CARACTERE('y');
1232: DECLARATION_CARACTERE('z');
1233:
1234: DECLARATION_CARACTERE('_');
1235:
1236: DECLARATION_CARACTERE('1');
1237: DECLARATION_CARACTERE('2');
1238: DECLARATION_CARACTERE('3');
1239: DECLARATION_CARACTERE('4');
1240: DECLARATION_CARACTERE('5');
1241: DECLARATION_CARACTERE('6');
1242: DECLARATION_CARACTERE('7');
1243: DECLARATION_CARACTERE('8');
1244: DECLARATION_CARACTERE('9');
1245: DECLARATION_CARACTERE('0');
1246: #undef DECLARATION_CARACTERE
1247:
1248: return;
1249: }
1250:
1251: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_variables.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src