--- rpl/src/gestion_variables.c 2011/06/19 17:48:27 1.33 +++ rpl/src/gestion_variables.c 2011/06/21 15:26:29 1.39 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0.prerelease.0 + RPL/2 (R) version 4.1.0.prerelease.2 Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -46,9 +46,18 @@ liste_variables_par_niveaux(struct_proce struct_liste_chainee *e; - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); printf(" Liste des variables par niveaux\n"); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); + + if ((*s_etat_processus).l_liste_variables_par_niveau == NULL) + { + printf("==========================================================" + "======================\n"); + return; + } printf("Backward\n"); l = (*s_etat_processus).l_liste_variables_par_niveau; @@ -62,8 +71,8 @@ liste_variables_par_niveaux(struct_proce while(e != NULL) { - printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, - e->donnee, ((struct_variable *) e->donnee)->niveau); + printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, + e, e->donnee, ((struct_variable *) e->donnee)->niveau); e = e->suivant; c++; if (c > 100) @@ -87,8 +96,8 @@ liste_variables_par_niveaux(struct_proce while(e != NULL) { - printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, - e->donnee, ((struct_variable *) e->donnee)->niveau); + printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, + e, e->donnee, ((struct_variable *) e->donnee)->niveau); e = e->suivant; c++; if (c > 100) exit(0); @@ -99,7 +108,8 @@ liste_variables_par_niveaux(struct_proce l = l->suivant; } while(l != (*s_etat_processus).l_liste_variables_par_niveau); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); if (fin == d_vrai) exit(0); @@ -119,9 +129,30 @@ liste_variables_tas(struct_processus *s_ fin = d_faux; + if (arbre == NULL) + { + return; + } + + printf(">>> Position : %d\n", + (*arbre).indice_tableau_pere); + printf(">>> Nombre de noeuds utilisés : %u\n", + (*arbre).noeuds_utilises); + printf(">>> Noeuds fils : "); + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*arbre).noeuds[i] != NULL) + { + printf("%d ", i); + } + } + + printf("\b\n"); + if ((*arbre).feuille != NULL) { - printf("Feuille %p\n", (*arbre).feuille); + printf("Feuille %p [%d]\n", (*arbre).feuille, (*arbre).noeuds_utilises); printf(" Backward\n"); @@ -157,10 +188,14 @@ liste_variables_tas(struct_processus *s_ } while((*arbre).feuille != l); } + printf("----------------------------------------------------------" + "----------------------\n"); + 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]); } } @@ -174,14 +209,17 @@ liste_variables_tas(struct_processus *s_ static void liste_variables_par_feuilles(struct_processus *s_etat_processus) { - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); printf(" Liste des variables sur le tas\n"); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); liste_variables_tas(s_etat_processus, (*s_etat_processus).s_arbre_variables); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); return; } @@ -341,6 +379,8 @@ ajout_variable(struct_processus *s_etat_ return(d_erreur); } + (*l_variable_courante).noeuds_utilises++; + (*(*l_variable_courante).feuille).suivant = (*l_variable_courante).feuille; (*(*l_variable_courante).feuille).precedent = @@ -426,13 +466,21 @@ ajout_variable(struct_processus *s_etat_ } while((l_variable_candidate != (*l_variable_courante).feuille) && ((*(*l_variable_candidate).variable).niveau <= 1)); + BUG((*s_variable).niveau == 0, + uprintf("Attempt to create a level-0 variable!\n")); + if ((*(*(*(*l_variable_courante).feuille).precedent).variable) .niveau > 1) { - // Ajout inconditionnel des variables de niveaux 0 et 1 + // La variable précédente est de niveau strictement supérieur + // à 1. Il ne peut donc y avoir aucune variable de niveau + // inférieur ou égal à 1 puisque la boucle est triée. + // On insère donc directement la variable en queue. } else { + // Le niveau de la variable précédente dans la boucle est + // inférieur ou égal à 1. l_variable_candidate = (*(*l_variable_courante).feuille) .precedent; } @@ -445,6 +493,17 @@ ajout_variable(struct_processus *s_etat_ (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; (*l_variable_candidate).precedent = l_nouvelle_variable; + // Si la variable suivant la variable que l'on vient d'insérer + // dans la boucle est de niveau 0, la variable insérée est par + // construction de niveau 1 et il convient de modifier le + // pointeur de feuille pointant sur l'élément de plus haut niveau + // de la boucle. + + if ((*(*(*l_nouvelle_variable).precedent).variable).niveau == 0) + { + (*(*l_nouvelle_variable).noeud).feuille = l_nouvelle_variable; + } + if (((*l_nouvelle_variable).variable = malloc(sizeof(struct_variable))) == NULL) { @@ -976,10 +1035,10 @@ retrait_variable(struct_processus *s_eta unsigned char *nom_variable, unsigned char type) { logical1 erreur; + logical1 variable_supprimee; struct_arbre_variables *s_arbre_a_supprimer; struct_arbre_variables *s_arbre_courant; - struct_arbre_variables *noeud_courant; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; @@ -989,6 +1048,8 @@ retrait_variable(struct_processus *s_eta unsigned long niveau; + (*s_etat_processus).niveau_supprime = d_faux; + if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) { // Une variable correspondant au nom recherché est accessible. @@ -1069,15 +1130,15 @@ retrait_variable(struct_processus *s_eta variable_a_supprimer = (*s_etat_processus) .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; - + s_arbre_courant = (*variable_a_supprimer).noeud; BUG((*s_arbre_courant).noeuds_utilises == 0, uprintf("Freed node !\n")); (*s_arbre_courant).noeuds_utilises--; + (*((*(*variable_a_supprimer).noeud_pere).noeuds + [(*(*variable_a_supprimer).noeud).indice_tableau_pere])) + .feuille = NULL; + while((*s_arbre_courant).noeuds_utilises == 0) { s_arbre_a_supprimer = s_arbre_courant; @@ -1087,6 +1148,8 @@ retrait_variable(struct_processus *s_eta { free((*s_arbre_a_supprimer).noeuds); free(s_arbre_a_supprimer); + + (*s_etat_processus).s_arbre_variables = NULL; break; } @@ -1142,8 +1205,6 @@ retrait_variable(struct_processus *s_eta (*(*s_etat_processus).pointeur_feuille_courante).suivant; (*s_etat_processus).pointeur_variable_courante = (*(*s_etat_processus).pointeur_feuille_courante).variable; - - noeud_courant = NULL; } // Dans tous les cas, on retire la variable de la liste des variables @@ -1151,6 +1212,7 @@ retrait_variable(struct_processus *s_eta niveau = (*(*variable_a_supprimer).variable).niveau; variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau; + variable_supprimee = d_faux; if (variables_par_niveau != NULL) { @@ -1189,6 +1251,36 @@ retrait_variable(struct_processus *s_eta } free(l_element_courant); + + if ((*variables_par_niveau).liste == NULL) + { + (*s_etat_processus).niveau_supprime = + d_vrai; + + if ((*s_etat_processus) + .l_liste_variables_par_niveau + == variables_par_niveau) + { + // On retire l'élément de la liste + // pointé par + // l_liste_variable_par_niveau + + (*s_etat_processus) + .l_liste_variables_par_niveau = + (*variables_par_niveau).suivant; + } + + (*(*variables_par_niveau).precedent) + .suivant = + (*variables_par_niveau).suivant; + (*(*variables_par_niveau).suivant) + .precedent = + (*variables_par_niveau) + .precedent; + free(variables_par_niveau); + } + + variable_supprimee = d_vrai; break; } @@ -1198,6 +1290,11 @@ retrait_variable(struct_processus *s_eta } } + if (variable_supprimee == d_vrai) + { + break; + } + variables_par_niveau = (*variables_par_niveau).suivant; } while(variables_par_niveau != (*s_etat_processus) @@ -1212,12 +1309,6 @@ retrait_variable(struct_processus *s_eta free(variable_a_supprimer); erreur = d_absence_erreur; - - if (noeud_courant != NULL) - { - free((*noeud_courant).noeuds); - free(noeud_courant); - } } else { @@ -1280,6 +1371,8 @@ retrait_variable_par_niveau(struct_proce while((*(*s_etat_processus).l_liste_variables_par_niveau).liste != NULL) { + // Nécessaire car le pointeur sur la tête de la pile + // peut être modifié par retrait_variable(). // Sauvegarde des variables statiques. if ((*((struct_variable *) (*(*(*s_etat_processus) @@ -1367,6 +1460,17 @@ retrait_variable_par_niveau(struct_proce { return(d_erreur); } + + if ((*((struct_variable *) (*(*(*s_etat_processus) + .l_liste_variables_par_niveau).liste).donnee)).niveau + <= (*s_etat_processus).niveau_courant) + { + // On a retiré de l'arbre des variables toutes les + // variables de niveau strictement supérieur au niveau + // courant. + + return(d_absence_erreur); + } } } @@ -1417,6 +1521,11 @@ liberation_arbre_variables(struct_proces // pas détruit par cette opération, il sera détruit lors de la libération // de la liste des variables par niveau. + if (arbre == NULL) + { + return; + } + l_element_courant = (*arbre).feuille; if (l_element_courant != NULL) @@ -1427,6 +1536,8 @@ liberation_arbre_variables(struct_proces free(l_element_courant); l_element_courant = l_element_suivant; } while(l_element_courant != (*arbre).feuille); + + (*arbre).feuille = NULL; } for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) @@ -1435,6 +1546,7 @@ liberation_arbre_variables(struct_proces { liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], retrait_definitions); + (*arbre).noeuds[i] = NULL; } } @@ -1460,11 +1572,11 @@ liberation_arbre_variables(struct_proces (*l_element_courant_liste).donnee)).objet); free((*((struct_variable *) (*l_element_courant_liste) .donnee)).nom); - free((*l_element_courant_liste).donnee); } l_element_suivant_liste = (*l_element_courant_liste).suivant; + free((*l_element_courant_liste).donnee); free(l_element_courant_liste); l_element_courant_liste = l_element_suivant_liste; } @@ -1479,6 +1591,7 @@ liberation_arbre_variables(struct_proces free((*arbre).noeuds); free(arbre); + arbre = NULL; return; } @@ -1585,19 +1698,115 @@ liste_variables(struct_processus *s_etat ================================================================================ */ -struct_arbre_variables * -copie_arbre_variables(struct_processus *s_etat_processus) +void +copie_arbre_variables(struct_processus *s_etat_processus, struct_processus + *s_nouvel_etat_processus) { // Les définitions sont partagées entre tous les threads et ne sont pas // copiées. // // NB : on ne copie que les variables de niveaux 0 et 1, les autres // variables locales étant masquées par le processus de création de thread - // ou de processus, elles sont inaccessibles. + // ou de processus, elles seront inaccessibles de tous les points + // du fil d'exécution fils. - BUG(1, uprintf("Oops !\n")); + // Pour copier ces variables, on récupère les variables depuis la liste par + // niveaux (niveaux 0 et 1) et on ajoute les variables dans la nouvelle + // structure. Les variables de niveau 0 étant non modifiables, elles + // ne sont pas dupliquées. - return(d_absence_erreur); + int i; + + struct_liste_chainee *l_element_courant; + + struct_liste_variables *l_niveau_courant; + + struct_variable s_variable; + + (*s_nouvel_etat_processus).s_arbre_variables = NULL; + (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL; + + l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau; + + // Si la variable en tête n'est pas une variable de niveau 0, le niveau + // 0, s'il existe est le nivau précédent la valeur courante dans la + // boucle. + + if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau + != 0) + { + l_niveau_courant = (*l_niveau_courant).precedent; + } + + // Les variables de niveaux 0 et 1 sont accessibles en au plus trois + // itérations (par construction). + + for(i = 0; i <= 2; i++) + { + if ((*((struct_variable *) (*(*l_niveau_courant).liste) + .donnee)).niveau == 0) + { + l_element_courant = (*l_niveau_courant).liste; + + while(l_element_courant != NULL) + { + if (ajout_variable(s_nouvel_etat_processus, + (struct_variable *) (*l_element_courant).donnee) + == d_erreur) + { + return; + } + + l_element_courant = (*l_element_courant).suivant; + } + } + else if ((*((struct_variable *) (*(*l_niveau_courant).liste) + .donnee)).niveau == 1) + { + l_element_courant = (*l_niveau_courant).liste; + + while(l_element_courant != NULL) + { + s_variable = (*((struct_variable *) + (*l_element_courant).donnee)); + + if ((s_variable.nom = strdup((*((struct_variable *) + (*l_element_courant).donnee)).nom)) == NULL) + { + (*s_nouvel_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((s_variable.objet = copie_objet(s_nouvel_etat_processus, + (*((struct_variable *) (*l_element_courant).donnee)) + .objet, 'P')) == NULL) + { + (*s_nouvel_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (ajout_variable(s_nouvel_etat_processus, &s_variable) + == d_erreur) + { + return; + } + + l_element_courant = (*l_element_courant).suivant; + } + + // Les variables de niveau 0 ayant déjà été copiées, on + // peut sortir de la boucle car toutes les variables sont + // maintenant disponibles dans le fil d'exécution fils. + + break; + } + + l_niveau_courant = (*l_niveau_courant).precedent; + } + + return; }