--- rpl/src/gestion_variables.c 2012/10/04 15:21:26 1.59 +++ rpl/src/gestion_variables.c 2013/04/01 15:29:34 1.75 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.11 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.14 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -237,7 +237,7 @@ liste_variables_par_feuilles(struct_proc ================================================================================ */ -static inline struct_arbre_variables * +struct_arbre_variables * allocation_noeud(struct_processus *s_etat_processus) { struct_arbre_variables *objet; @@ -272,7 +272,7 @@ liberation_noeud(struct_processus *s_eta return; } -static inline struct_arbre_variables ** +struct_arbre_variables ** allocation_tableau_noeuds(struct_processus *s_etat_processus) { struct_arbre_variables **objet; @@ -284,7 +284,8 @@ allocation_tableau_noeuds(struct_process } else { - objet = malloc((*s_etat_processus).nombre_caracteres_variables + objet = malloc(((size_t) (*s_etat_processus) + .nombre_caracteres_variables) * sizeof(struct_arbre_variables *)); } @@ -432,7 +433,7 @@ ajout_variable(struct_processus *s_etat_ (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL; if (((*(*s_etat_processus).s_arbre_variables).noeuds = - allocation_tableau_noeuds(s_etat_processus)) == NULL) + allocation_tableau_noeuds(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -988,7 +989,7 @@ recherche_variable(struct_processus *s_e unsigned char *ptr; - unsigned long niveau_appel; + integer8 niveau_appel; if ((*s_etat_processus).s_arbre_variables == NULL) { @@ -1203,7 +1204,7 @@ retrait_variable(struct_processus *s_eta struct_liste_variables *variable_a_supprimer; struct_liste_variables *variables_par_niveau; - unsigned long niveau; + integer8 niveau; (*s_etat_processus).niveau_supprime = d_faux; @@ -1530,6 +1531,15 @@ retrait_variables_par_niveau(struct_proc break; } + if (((*s_etat_processus).at_exit != NULL) && + ((*s_etat_processus).niveau_courant == 0)) + { + // Il y a une routine ATEXIT enregistrée. On ne détruit pas + // les variables globales qui pourraient y être utilisées. + + break; + } + while((*(*s_etat_processus).l_liste_variables_par_niveau).liste != NULL) { @@ -1712,6 +1722,8 @@ liberation_arbre_variables(struct_proces free((*(*l_element_statique_courant).variable).nom); liberation(s_etat_processus, (*(*l_element_statique_courant) .variable).objet); + free((*l_element_statique_courant).variable); + free(l_element_statique_courant); l_element_statique_courant = l_element_statique_suivant; } @@ -1787,14 +1799,20 @@ liberation_arbre_variables(struct_proces ================================================================================ */ -int -nombre_variables(struct_processus *s_etat_processus, +static integer8 +nombre_variables_locales(struct_processus *s_etat_processus, struct_arbre_variables *l_element_courant) { - int i; - int n; + integer8 i; + integer8 n; - struct_liste_variables *l_variable; + struct_liste_variables *l_variable; + struct_liste_variables_statiques *l_variable_statique; + + if (l_element_courant == NULL) + { + return(0); + } n = 0; @@ -1809,11 +1827,29 @@ nombre_variables(struct_processus *s_eta } while(l_variable != (*l_element_courant).feuille); } + if ((*l_element_courant).feuille_statique != NULL) + { + l_variable_statique = (*l_element_courant).feuille_statique; + + do + { + // Si le pointeur est nul, la variable est accessible et a été + // copiée dans l'arbre des variables. + + if ((*(*l_variable_statique).variable).objet != NULL) + { + n++; + } + + l_variable_statique = (*l_variable_statique).suivant; + } while(l_variable_statique != NULL); + } + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) { if ((*l_element_courant).noeuds[i] != NULL) { - n += nombre_variables(s_etat_processus, + n += nombre_variables_locales(s_etat_processus, (*l_element_courant).noeuds[i]); } } @@ -1822,14 +1858,113 @@ nombre_variables(struct_processus *s_eta } -int -liste_variables(struct_processus *s_etat_processus, - struct_tableau_variables *tableau, int position, +static integer8 +nombre_variables_partagees(struct_processus *s_etat_processus, + struct_arbre_variables_partagees *l_element_courant) +{ + integer8 i; + integer8 n; + + struct_liste_variables_partagees *l_variable; + + if (l_element_courant == NULL) + { + return(0); + } + + // Mutex deverrouillé par liste_variables_partagees(); + if (pthread_mutex_lock(&((*l_element_courant).mutex_feuille)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(0); + } + + n = 0; + + if ((*l_element_courant).feuille != NULL) + { + l_variable = (*l_element_courant).feuille; + + do + { + n++; + l_variable = (*l_variable).suivant; + } while(l_variable != NULL); + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*l_element_courant).noeuds[i] != NULL) + { + n += nombre_variables_partagees(s_etat_processus, + (*l_element_courant).noeuds[i]); + } + } + + return(n); +} + + +integer8 +nombre_variables(struct_processus *s_etat_processus) +{ + return(nombre_variables_locales(s_etat_processus, + (*s_etat_processus).s_arbre_variables) + + nombre_variables_partagees(s_etat_processus, + (*(*s_etat_processus).s_arbre_variables_partagees))); +} + + +void +liberation_mutexes_arbre_variables_partagees(struct_processus *s_etat_processus, + struct_arbre_variables_partagees *l_element_courant) +{ + int i; + + if (l_element_courant == NULL) + { + return; + } + + if (pthread_mutex_trylock(&((*l_element_courant).mutex_feuille)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*l_element_courant).noeuds[i] != NULL) + { + liberation_mutexes_arbre_variables_partagees(s_etat_processus, + (*l_element_courant).noeuds[i]); + } + } + + return; +} + + +static integer8 +liste_variables_locales(struct_processus *s_etat_processus, + struct_tableau_variables *tableau, integer8 position, struct_arbre_variables *l_element_courant) { - int i; + integer8 i; - struct_liste_variables *l_variable; + struct_liste_variables *l_variable; + struct_liste_variables_statiques *l_variable_statique; + + if (l_element_courant == NULL) + { + return(position); + } if ((*l_element_courant).feuille != NULL) { @@ -1847,17 +1982,47 @@ liste_variables(struct_processus *s_etat (*(*l_variable).variable).variable_statique; tableau[position].variable_partagee = (*(*l_variable).variable).variable_partagee; + tableau[position].variable_masquee = d_faux; + tableau[position].mutex = NULL; position++; + l_variable = (*l_variable).suivant; } while(l_variable != (*l_element_courant).feuille); } + if ((*l_element_courant).feuille_statique != NULL) + { + l_variable_statique = (*l_element_courant).feuille_statique; + + do + { + if ((*(*l_variable_statique).variable).objet != NULL) + { + tableau[position].origine = 'E'; + tableau[position].nom = (*(*l_variable_statique).variable).nom; + tableau[position].niveau = + (*(*l_variable_statique).variable).niveau; + tableau[position].objet = (*(*l_variable_statique).variable) + .objet; + tableau[position].variable_verrouillee = d_faux; + tableau[position].variable_statique = + (*(*l_variable_statique).variable).variable_statique; + tableau[position].variable_partagee.pointeur = NULL; + tableau[position].variable_masquee = d_vrai; + + position++; + } + + l_variable_statique = (*l_variable_statique).suivant; + } while(l_variable_statique != NULL); + } + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) { if ((*l_element_courant).noeuds[i] != NULL) { - position = liste_variables(s_etat_processus, + position = liste_variables_locales(s_etat_processus, tableau, position, (*l_element_courant).noeuds[i]); } } @@ -1866,6 +2031,107 @@ liste_variables(struct_processus *s_etat } +static integer8 +liste_variables_partagees(struct_processus *s_etat_processus, + struct_tableau_variables *tableau, integer8 position, + struct_arbre_variables_partagees *l_element_courant) +{ + integer8 i; + + struct_liste_variables_partagees *l_variable; + + if (l_element_courant == NULL) + { + return(position); + } + + if ((*l_element_courant).feuille != NULL) + { + l_variable = (*l_element_courant).feuille; + + do + { + tableau[position].origine = 'E'; + 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 = d_faux; + tableau[position].variable_partagee = + (*(*l_variable).variable).variable_partagee; + tableau[position].variable_statique.pointeur = NULL; + tableau[position].variable_masquee = d_faux; + tableau[position].mutex = &((*(*l_variable).variable).mutex); + pthread_mutex_lock(tableau[position].mutex); + + position++; + + l_variable = (*l_variable).suivant; + } while(l_variable != NULL); + } + + for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) + { + if ((*l_element_courant).noeuds[i] != NULL) + { + position = liste_variables_partagees(s_etat_processus, + tableau, position, (*l_element_courant).noeuds[i]); + } + } + + // Mutex verrouillé par nombre_variables_partagees(); + if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(0); + } + + return(position); +} + + +static int +fonction_ordre_variables(const void *argument_1, const void *argument_2) +{ + int comparaison; + + struct_tableau_variables *a1; + struct_tableau_variables *a2; + + a1 = (struct_tableau_variables *) argument_1; + a2 = (struct_tableau_variables *) argument_2; + + comparaison = strcmp((*a1).nom, (*a2).nom); + + if (comparaison != 0) + { + return(comparaison); + } + else + { + return(((((*a1).niveau - (*a2).niveau)) > 0) ? 1 : -1); + } +} + + +integer8 +liste_variables(struct_processus *s_etat_processus, + struct_tableau_variables *tableau) +{ + integer8 nombre_elements; + + nombre_elements = liste_variables_locales(s_etat_processus, + tableau, 0, (*s_etat_processus).s_arbre_variables); + nombre_elements = liste_variables_partagees(s_etat_processus, + tableau, nombre_elements, (*(*s_etat_processus) + .s_arbre_variables_partagees)); + + qsort(tableau, (size_t) nombre_elements, sizeof(struct_tableau_variables), + fonction_ordre_variables); + + return(nombre_elements); +} + + /* ================================================================================ Procédure de copie de l'arbre des variables @@ -1895,16 +2161,22 @@ copie_arbre_variables(struct_processus * // structure. Les variables de niveau 0 étant non modifiables, elles // ne sont pas dupliquées. - int i; + int i; + + logical1 niveau_0_traite; + logical1 niveau_1_traite; + + struct_arbre_variables *l_variable_courante; - logical1 niveau_0_traite; - logical1 niveau_1_traite; + struct_liste_chainee *l_element_courant; - struct_liste_chainee *l_element_courant; + struct_liste_variables *l_niveau_courant; + struct_liste_variables_statiques *l_element_statique_courant; - struct_liste_variables *l_niveau_courant; + struct_variable s_variable; + struct_variable_statique s_variable_statique; - struct_variable s_variable; + unsigned char *ptr; (*s_nouvel_etat_processus).s_arbre_variables = NULL; (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL; @@ -2002,6 +2274,163 @@ copie_arbre_variables(struct_processus * l_niveau_courant = (*l_niveau_courant).precedent; } + // Copie des variables statiques + + l_element_statique_courant = (*s_etat_processus) + .l_liste_variables_statiques; + + while(l_element_statique_courant != NULL) + { + // Création des branches de l'arbre si nécessaire. + + if ((*s_nouvel_etat_processus).s_arbre_variables == NULL) + { + if (((*s_nouvel_etat_processus).s_arbre_variables = + allocation_noeud(s_nouvel_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*(*s_nouvel_etat_processus).s_arbre_variables).feuille = NULL; + (*(*s_nouvel_etat_processus).s_arbre_variables).feuille_statique + = NULL; + (*(*s_nouvel_etat_processus).s_arbre_variables).noeuds_utilises = 0; + (*(*s_nouvel_etat_processus).s_arbre_variables).indice_tableau_pere + = -1; + (*(*s_nouvel_etat_processus).s_arbre_variables).noeud_pere = NULL; + + if (((*(*s_nouvel_etat_processus).s_arbre_variables).noeuds = + allocation_tableau_noeuds(s_nouvel_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + for(i = 0; i < (*s_nouvel_etat_processus) + .nombre_caracteres_variables; i++) + { + (*(*s_nouvel_etat_processus).s_arbre_variables).noeuds[i] + = NULL; + } + } + + l_variable_courante = (*s_nouvel_etat_processus).s_arbre_variables; + ptr = (*(*l_element_statique_courant).variable).nom; + + while((*ptr) != d_code_fin_chaine) + { + BUG((*s_nouvel_etat_processus).pointeurs_caracteres_variables + [*ptr] < 0, uprintf("Variable=\"%s\", (*ptr)='%c'\n", + (*(*l_element_statique_courant).variable).nom, *ptr)); + + if ((*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]] == NULL) + { + // Le noeud n'existe pas encore, on le crée et on le marque + // comme utilisé dans la structure parente. + + if (((*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]] = + allocation_noeud(s_nouvel_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*l_variable_courante).noeuds_utilises++; + + // La feuille est par défaut vide et aucun élément du tableau + // noeuds (les branches qui peuvent être issues de ce nouveau + // noeud) n'est encore utilisée. + + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).feuille = NULL; + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).feuille_statique + = NULL; + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises + = 0; + + // Le champ noeud_pere de la structure créée pointe sur + // la structure parente et l'indice tableau_pere correspond à la + // position réelle dans le tableau noeuds[] de la structure + // parente du noeud courant. Cette valeur sera utilisée lors de + // la destruction du noeud pour annuler le pointeur contenu dans + // le tableau noeuds[] de la structure parente. + + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).noeud_pere = + l_variable_courante; + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]) + .indice_tableau_pere = (*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]; + + // Allocation du tableau noeuds[] et initialisation à zéro de + // tous les pointeurs. + + if (((*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).noeuds = + allocation_tableau_noeuds(s_nouvel_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme + = d_es_allocation_memoire; + return; + } + + for(i = 0; i < (*s_nouvel_etat_processus) + .nombre_caracteres_variables; i++) + { + (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) + .pointeurs_caracteres_variables[*ptr]]).noeuds[i] + = NULL; + } + } + + l_variable_courante = (*l_variable_courante).noeuds + [(*s_nouvel_etat_processus).pointeurs_caracteres_variables + [*ptr]]; + + ptr++; + } + + // Il faut copier la variable pour la dissocier de la variable + // restant dans le thread parent. + + s_variable_statique = (*(*l_element_statique_courant).variable); + + if (copie_objet(s_etat_processus, s_variable_statique.objet, 'P') + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((s_variable_statique.nom = malloc((strlen( + (*(*l_element_statique_courant).variable).nom) + 1) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + strcpy(s_variable_statique.nom, (*(*l_element_statique_courant) + .variable).nom); + + if (creation_variable_statique(s_nouvel_etat_processus, + &s_variable_statique) == d_erreur) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + l_element_statique_courant = (*l_element_statique_courant).suivant; + } + return; } @@ -2049,7 +2478,7 @@ initialisation_variables(struct_processu } if (((*s_etat_processus).pointeurs_caracteres_variables = - malloc(longueur_tableau * sizeof(int))) == NULL) + malloc(((size_t) longueur_tableau) * sizeof(int))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return;