--- rpl/src/gestion_variables.c 2011/06/21 07:45:22 1.37 +++ rpl/src/gestion_variables.c 2011/06/21 15:03:58 1.38 @@ -46,13 +46,16 @@ 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"); + printf("==========================================================" + "======================\n"); return; } @@ -68,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) @@ -93,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); @@ -105,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); @@ -184,7 +188,8 @@ liste_variables_tas(struct_processus *s_ } while((*arbre).feuille != l); } - printf("-----------------------------------------------------------\n"); + printf("----------------------------------------------------------" + "----------------------\n"); for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) { @@ -204,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; } @@ -1122,7 +1130,6 @@ retrait_variable(struct_processus *s_eta variable_a_supprimer = (*s_etat_processus) .pointeur_feuille_courante; - //s_arbre_courant = (*variable_a_supprimer).noeud_pere; s_arbre_courant = (*variable_a_supprimer).noeud; BUG((*s_arbre_courant).noeuds_utilises == 0, uprintf("Freed node !\n")); @@ -1529,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++) @@ -1537,6 +1546,7 @@ liberation_arbre_variables(struct_proces { liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], retrait_definitions); + (*arbre).noeuds[i] = NULL; } } @@ -1562,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; } @@ -1581,6 +1591,7 @@ liberation_arbre_variables(struct_proces free((*arbre).noeuds); free(arbre); + arbre = NULL; return; } @@ -1687,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; }