--- rpl/src/gestion_variables.c 2011/06/17 08:47:43 1.32 +++ rpl/src/gestion_variables.c 2011/06/19 17:48:27 1.33 @@ -25,13 +25,178 @@ /* ================================================================================ + Fonction de debug +================================================================================ + Entrée : +-------------------------------------------------------------------------------- + Sortie : +-------------------------------------------------------------------------------- + Effets de bords : néant +================================================================================ +*/ + +static void +liste_variables_par_niveaux(struct_processus *s_etat_processus) +{ + int c; + + logical1 fin; + + struct_liste_variables *l; + + struct_liste_chainee *e; + + printf("===========================================================\n"); + printf(" Liste des variables par niveaux\n"); + printf("===========================================================\n"); + + printf("Backward\n"); + l = (*s_etat_processus).l_liste_variables_par_niveau; + c = 0; + fin = d_faux; + + do + { + l = l->precedent; + e = l->liste; + + while(e != NULL) + { + printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, + e->donnee, ((struct_variable *) e->donnee)->niveau); + e = e->suivant; + c++; + if (c > 100) + { + fin = d_vrai; + break; + } + } + + printf("\n"); + + } while(l != (*s_etat_processus).l_liste_variables_par_niveau); + + printf("Forward\n"); + l = (*s_etat_processus).l_liste_variables_par_niveau; + c = 0; + + do + { + e = l->liste; + + while(e != NULL) + { + printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, + e->donnee, ((struct_variable *) e->donnee)->niveau); + e = e->suivant; + c++; + if (c > 100) exit(0); + } + + printf("\n"); + + l = l->suivant; + } while(l != (*s_etat_processus).l_liste_variables_par_niveau); + + printf("===========================================================\n"); + + if (fin == d_vrai) exit(0); + + return; +} + +static void +liste_variables_tas(struct_processus *s_etat_processus, + struct_arbre_variables *arbre) +{ + int c; + int i; + + logical1 fin; + + struct_liste_variables *l; + + fin = d_faux; + + if ((*arbre).feuille != NULL) + { + printf("Feuille %p\n", (*arbre).feuille); + + printf(" Backward\n"); + + l = (*arbre).feuille; + c = 0; + fin = d_faux; + + do + { + l = l->precedent; + c++; + if (c > 100) + { + fin = d_vrai; + break; + } + printf(" %s (%p, %d)\n", l->variable->nom, l->variable, + l->variable->niveau); + } while((*arbre).feuille != l); + + printf(" Forward\n"); + + l = (*arbre).feuille; + c = 0; + + do + { + c++; + if (c > 100) exit(0); + printf(" %s (%p, %d)\n", l->variable->nom, l->variable, + l->variable->niveau); + l = l->suivant; + } while((*arbre).feuille != l); + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*arbre).noeuds[i] != NULL) + { + liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]); + } + } + + if (fin == d_vrai) exit(0); + + return; +} + + +static void +liste_variables_par_feuilles(struct_processus *s_etat_processus) +{ + printf("===========================================================\n"); + printf(" Liste des variables sur le tas\n"); + printf("===========================================================\n"); + + liste_variables_tas(s_etat_processus, + (*s_etat_processus).s_arbre_variables); + + printf("===========================================================\n"); + + return; +} + + +/* +================================================================================ Routine de création d'une nouvelle variable - Entrée : autorisation_creation_variable_statique vaut 'V' ou 'S'. - Dans le cas 'V', la variable est volatile. - Dans le cas 'S', elle est statique. - Entrée : autorisation_creation_variable_partagee vaut 'P' ou 'S'. - Dans le cas 'P', la variable est privée. - Dans le cas 'S', elle est partagée. +================================================================================ + Entrée : autorisation_creation_variable_statique vaut 'v' ou 's'. + dans le cas 'v', la variable est volatile. + dans le cas 's', elle est statique. + Entrée : autorisation_creation_variable_partagee vaut 'p' ou 's'. + dans le cas 'p', la variable est privée. + dans le cas 's', elle est partagée. -------------------------------------------------------------------------------- Sortie : -------------------------------------------------------------------------------- @@ -44,8 +209,11 @@ ajout_variable(struct_processus *s_etat_ { int i; + logical1 niveau_acceptable; + struct_liste_variables *l_nouvelle_variable; struct_liste_variables *l_variable_candidate; + struct_arbre_variables *l_variable_courante; struct_arbre_variables *l_variable_precedente; @@ -220,6 +388,7 @@ ajout_variable(struct_processus *s_etat_ (*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille) .precedent; (*l_nouvelle_variable).noeud_pere = l_variable_precedente; + (*l_nouvelle_variable).noeud = l_variable_courante; (*(*(*l_variable_courante).feuille).precedent).suivant = l_nouvelle_variable; (*(*l_variable_courante).feuille).precedent = @@ -272,6 +441,7 @@ ajout_variable(struct_processus *s_etat_ (*l_nouvelle_variable).precedent = (*l_variable_candidate) .precedent; (*l_nouvelle_variable).noeud_pere = l_variable_precedente; + (*l_nouvelle_variable).noeud = l_variable_courante; (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; (*l_variable_candidate).precedent = l_nouvelle_variable; @@ -308,6 +478,20 @@ ajout_variable(struct_processus *s_etat_ (*l_nouvelle_variable).liste = NULL; (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable; + + // Ajout de la variable en tête de la liste + + if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(d_erreur); + } + + (*l_nouvel_element).suivant = (*(*s_etat_processus) + .l_liste_variables_par_niveau).liste; + (*l_nouvel_element).donnee = pointeur_variable_cree; + (*(*s_etat_processus).l_liste_variables_par_niveau).liste = + l_nouvel_element; } else if ((*s_variable).niveau > (*((struct_variable *) (*(*(*s_etat_processus).l_liste_variables_par_niveau).liste) @@ -330,54 +514,112 @@ ajout_variable(struct_processus *s_etat_ (*l_nouvelle_variable).liste = NULL; (*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent) .suivant = l_nouvelle_variable; - (*(*s_etat_processus).l_liste_variables_par_niveau).precedent = - l_nouvelle_variable; + (*(*s_etat_processus).l_liste_variables_par_niveau) + .precedent = l_nouvelle_variable; (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable; - } - else if ((*s_variable).niveau <= 1) - { - // Création d'une variable de niveau 0 ou 1 - if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) - == NULL) + // Ajout de la variable en tête de la liste + + if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); } + (*l_nouvel_element).suivant = (*(*s_etat_processus) + .l_liste_variables_par_niveau).liste; + (*l_nouvel_element).donnee = pointeur_variable_cree; + (*(*s_etat_processus).l_liste_variables_par_niveau).liste = + l_nouvel_element; + } + else if ((*s_variable).niveau <= 1) + { + // Création d'une variable de niveau 0 ou 1. Il convient de + // chercher dans la liste si un niveau 0 ou 1 préexiste. Pour cela, on + // regarde la position courante et les deux précédentes. + l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau; + niveau_acceptable = d_faux; - if ((*((struct_variable *) (*(*(*(*s_etat_processus) - .l_liste_variables_par_niveau).precedent).liste).donnee)) - .niveau <= 1) + for(i = 0; i <= 2; i++) { - l_variable_candidate = (*(*s_etat_processus) - .l_liste_variables_par_niveau).precedent; + if ((*l_variable_candidate).liste == NULL) + { + continue; + } + + if ((*((struct_variable *) (*(*l_variable_candidate) + .liste).donnee)).niveau == (*s_variable).niveau) + { + niveau_acceptable = d_vrai; + break; + } + + l_variable_candidate = (*l_variable_candidate).precedent; } - (*l_nouvelle_variable).suivant = l_variable_candidate; - (*l_nouvelle_variable).precedent = (*l_variable_candidate) - .precedent; - (*l_nouvelle_variable).noeud_pere = NULL; - (*l_nouvelle_variable).liste = NULL; - (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; - (*l_variable_candidate).precedent = l_nouvelle_variable; - } + if (niveau_acceptable == d_faux) + { + if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(d_erreur); + } - // Ajout de la variable en tête de la liste + l_variable_candidate = + (*(*s_etat_processus).l_liste_variables_par_niveau) + .precedent; - if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(d_erreur); + // On ne peut créer qu'une variable de niveau supérieur ou égal à + // 1 lors de l'exécution normale d'un programme. Les variables + // de niveau 0 sont créées à l'initialisation et relèvent du + // cas précédent car il n'existe lors de leur création aucun + // niveau non nul. + + BUG((*s_variable).niveau == 0, + uprintf("Attempt to create a level-0 variable!\n")); + + (*l_nouvelle_variable).suivant = l_variable_candidate; + (*l_nouvelle_variable).precedent = (*l_variable_candidate) + .precedent; + (*l_nouvelle_variable).noeud_pere = NULL; + (*l_nouvelle_variable).liste = NULL; + (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; + (*l_variable_candidate).precedent = l_nouvelle_variable; + + l_variable_candidate = l_nouvelle_variable; + } + + // Ajout de la variable en tête de la liste l_variable_candidate. + + if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(d_erreur); + } + + (*l_nouvel_element).suivant = (*l_variable_candidate).liste; + (*l_nouvel_element).donnee = pointeur_variable_cree; + (*l_variable_candidate).liste = l_nouvel_element; } + else + { + // Ajout de la variable en tête de la liste - (*l_nouvel_element).suivant = (*(*s_etat_processus) - .l_liste_variables_par_niveau).liste; - (*l_nouvel_element).donnee = pointeur_variable_cree; - (*(*s_etat_processus).l_liste_variables_par_niveau).liste = - l_nouvel_element; + if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(d_erreur); + } + + (*l_nouvel_element).suivant = (*(*s_etat_processus) + .l_liste_variables_par_niveau).liste; + (*l_nouvel_element).donnee = pointeur_variable_cree; + (*(*s_etat_processus).l_liste_variables_par_niveau).liste = + l_nouvel_element; + } return(d_absence_erreur); } @@ -617,21 +859,23 @@ recherche_variable(struct_processus *s_e (*s_etat_processus).pointeur_variable_courante = (*(*(*l_variable_courante).feuille).precedent).variable; (*s_etat_processus).pointeur_feuille_courante = - (*l_variable_courante).feuille; + (*(*l_variable_courante).feuille).precedent; // S'il existe une variable de niveau 0 et une seconde de // niveau 1, la variable de niveau 0 (fonction) est masquée // par celle de niveau 1. - if (((*(*(*l_variable_courante).feuille).variable).niveau == 0) - && ((*(*(*(*l_variable_courante).feuille).precedent) + if (((*(*(*(*l_variable_courante).feuille).precedent) + .variable).niveau == 0) && ((*(*(*(* + (*l_variable_courante).feuille).precedent).precedent) .variable).niveau == 1)) { (*s_etat_processus).pointeur_variable_courante = - (*(*(*l_variable_courante).feuille).precedent) - .variable; + (*(*(*(*l_variable_courante).feuille).precedent) + .precedent).variable; (*s_etat_processus).pointeur_feuille_courante = - (*l_variable_courante).feuille; + (*(*(*l_variable_courante).feuille).precedent) + .precedent; } return(d_vrai); @@ -658,9 +902,7 @@ recherche_variable_globale(struct_proces { case 0: { - // Nous sommes en présence d'une définition et non d'une - // variable. - + // La variable est une définition. presence_variable = d_faux; break; } @@ -829,6 +1071,8 @@ retrait_variable(struct_processus *s_eta .pointeur_feuille_courante; s_arbre_courant = (*variable_a_supprimer).noeud_pere; noeud_courant = (*variable_a_supprimer).noeud; + (*s_arbre_courant).noeuds[(*noeud_courant).indice_tableau_pere] + = NULL; BUG((*s_arbre_courant).noeuds_utilises == 0, uprintf("Freed node !\n")); @@ -879,6 +1123,26 @@ retrait_variable(struct_processus *s_eta .precedent = (*(*s_etat_processus) .pointeur_feuille_courante).precedent; + // Mise à jour du pointeur dans l'arbre des variables. Cette + // mise à jour n'est nécessaire que dans le cas où la variable + // supprimée est en tête de la liste. + + if (variable_a_supprimer == (*((*(*variable_a_supprimer).noeud_pere) + .noeuds[(*(*variable_a_supprimer).noeud) + .indice_tableau_pere])).feuille) + { + (*((*(*variable_a_supprimer).noeud_pere).noeuds + [(*(*variable_a_supprimer).noeud).indice_tableau_pere])) + .feuille = (*(*((*(*variable_a_supprimer).noeud_pere) + .noeuds[(*(*variable_a_supprimer).noeud) + .indice_tableau_pere])).feuille).suivant; + } + + (*s_etat_processus).pointeur_feuille_courante = + (*(*s_etat_processus).pointeur_feuille_courante).suivant; + (*s_etat_processus).pointeur_variable_courante = + (*(*s_etat_processus).pointeur_feuille_courante).variable; + noeud_courant = NULL; } @@ -945,12 +1209,12 @@ retrait_variable(struct_processus *s_eta free((*(*variable_a_supprimer).variable).nom); liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet); free((*variable_a_supprimer).variable); + free(variable_a_supprimer); erreur = d_absence_erreur; if (noeud_courant != NULL) { - free((*noeud_courant).feuille); free((*noeud_courant).noeuds); free(noeud_courant); } @@ -1222,6 +1486,95 @@ liberation_arbre_variables(struct_proces /* ================================================================================ + Procédure renvoyant les variables dans un tableau +================================================================================ + Entrée : +-------------------------------------------------------------------------------- + Sortie : +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +int +nombre_variables(struct_processus *s_etat_processus, + struct_arbre_variables *l_element_courant) +{ + int i; + int n; + + struct_liste_variables *l_variable; + + n = 0; + + if ((*l_element_courant).feuille != NULL) + { + l_variable = (*l_element_courant).feuille; + + do + { + n++; + l_variable = (*l_variable).suivant; + } while(l_variable != (*l_element_courant).feuille); + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*l_element_courant).noeuds[i] != NULL) + { + n += nombre_variables(s_etat_processus, + (*l_element_courant).noeuds[i]); + } + } + + return(n); +} + +int +liste_variables(struct_processus *s_etat_processus, + struct_tableau_variables *tableau, int position, + struct_arbre_variables *l_element_courant) +{ + int i; + + struct_liste_variables *l_variable; + + if ((*l_element_courant).feuille != NULL) + { + l_variable = (*l_element_courant).feuille; + + do + { + tableau[position].origine = (*(*l_variable).variable).origine; + tableau[position].nom = (*(*l_variable).variable).nom; + tableau[position].niveau = (*(*l_variable).variable).niveau; + tableau[position].objet = (*(*l_variable).variable).objet; + tableau[position].variable_verrouillee = + (*(*l_variable).variable).variable_verrouillee; + tableau[position].variable_statique = + (*(*l_variable).variable).variable_statique; + tableau[position].variable_partagee = + (*(*l_variable).variable).variable_partagee; + + position++; + l_variable = (*l_variable).suivant; + } while(l_variable != (*l_element_courant).feuille); + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*l_element_courant).noeuds[i] != NULL) + { + position = liste_variables(s_etat_processus, + tableau, position, (*l_element_courant).noeuds[i]); + } + } + + return(position); +} + +/* +================================================================================ Procédure de copie de l'arbre des variables ================================================================================ Entrée :