version 1.33, 2011/06/19 17:48:27
|
version 1.40, 2011/06/22 12:48:30
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
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 |
Copyright (C) 1989-2011 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
Line 46 liste_variables_par_niveaux(struct_proce
|
Line 46 liste_variables_par_niveaux(struct_proce
|
|
|
struct_liste_chainee *e; |
struct_liste_chainee *e; |
|
|
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
printf(" Liste des variables par niveaux\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"); |
printf("Backward\n"); |
l = (*s_etat_processus).l_liste_variables_par_niveau; |
l = (*s_etat_processus).l_liste_variables_par_niveau; |
Line 62 liste_variables_par_niveaux(struct_proce
|
Line 71 liste_variables_par_niveaux(struct_proce
|
|
|
while(e != NULL) |
while(e != NULL) |
{ |
{ |
printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, |
printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, |
e->donnee, ((struct_variable *) e->donnee)->niveau); |
e, e->donnee, ((struct_variable *) e->donnee)->niveau); |
e = e->suivant; |
e = e->suivant; |
c++; |
c++; |
if (c > 100) |
if (c > 100) |
Line 87 liste_variables_par_niveaux(struct_proce
|
Line 96 liste_variables_par_niveaux(struct_proce
|
|
|
while(e != NULL) |
while(e != NULL) |
{ |
{ |
printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, |
printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, |
e->donnee, ((struct_variable *) e->donnee)->niveau); |
e, e->donnee, ((struct_variable *) e->donnee)->niveau); |
e = e->suivant; |
e = e->suivant; |
c++; |
c++; |
if (c > 100) exit(0); |
if (c > 100) exit(0); |
Line 99 liste_variables_par_niveaux(struct_proce
|
Line 108 liste_variables_par_niveaux(struct_proce
|
l = l->suivant; |
l = l->suivant; |
} while(l != (*s_etat_processus).l_liste_variables_par_niveau); |
} while(l != (*s_etat_processus).l_liste_variables_par_niveau); |
|
|
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
|
|
if (fin == d_vrai) exit(0); |
if (fin == d_vrai) exit(0); |
|
|
Line 119 liste_variables_tas(struct_processus *s_
|
Line 129 liste_variables_tas(struct_processus *s_
|
|
|
fin = d_faux; |
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) |
if ((*arbre).feuille != NULL) |
{ |
{ |
printf("Feuille %p\n", (*arbre).feuille); |
printf("Feuille %p [%d]\n", (*arbre).feuille, (*arbre).noeuds_utilises); |
|
|
printf(" Backward\n"); |
printf(" Backward\n"); |
|
|
Line 157 liste_variables_tas(struct_processus *s_
|
Line 188 liste_variables_tas(struct_processus *s_
|
} while((*arbre).feuille != l); |
} while((*arbre).feuille != l); |
} |
} |
|
|
|
printf("----------------------------------------------------------" |
|
"----------------------\n"); |
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
{ |
{ |
if ((*arbre).noeuds[i] != NULL) |
if ((*arbre).noeuds[i] != NULL) |
{ |
{ |
|
|
liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]); |
liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]); |
} |
} |
} |
} |
Line 174 liste_variables_tas(struct_processus *s_
|
Line 209 liste_variables_tas(struct_processus *s_
|
static void |
static void |
liste_variables_par_feuilles(struct_processus *s_etat_processus) |
liste_variables_par_feuilles(struct_processus *s_etat_processus) |
{ |
{ |
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
printf(" Liste des variables sur le tas\n"); |
printf(" Liste des variables sur le tas\n"); |
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
|
|
liste_variables_tas(s_etat_processus, |
liste_variables_tas(s_etat_processus, |
(*s_etat_processus).s_arbre_variables); |
(*s_etat_processus).s_arbre_variables); |
|
|
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
|
|
|
return; |
|
} |
|
|
|
|
|
/* |
|
================================================================================ |
|
Routine de gestion du cache mémoire sur l'arbre des variables |
|
================================================================================ |
|
Entrée : |
|
-------------------------------------------------------------------------------- |
|
Sortie : |
|
-------------------------------------------------------------------------------- |
|
Effets de bords : néant |
|
================================================================================ |
|
*/ |
|
|
|
static inline struct_arbre_variables * |
|
allocation_noeud(struct_processus *s_etat_processus) |
|
{ |
|
struct_arbre_variables *objet; |
|
|
|
if ((*s_etat_processus).pointeur_variables_noeud > 0) |
|
{ |
|
objet = (*s_etat_processus).variables_noeud |
|
[--(*s_etat_processus).pointeur_variables_noeud]; |
|
} |
|
else |
|
{ |
|
objet = malloc(sizeof(struct_arbre_variables)); |
|
} |
|
|
|
return(objet); |
|
} |
|
|
|
static inline void |
|
liberation_noeud(struct_processus *s_etat_processus, |
|
struct_arbre_variables *objet) |
|
{ |
|
if ((*s_etat_processus).pointeur_variables_noeud < TAILLE_CACHE) |
|
{ |
|
(*s_etat_processus).variables_noeud |
|
[(*s_etat_processus).pointeur_variables_noeud++] = objet; |
|
} |
|
else |
|
{ |
|
free(objet); |
|
} |
|
|
|
return; |
|
} |
|
|
|
static inline struct_arbre_variables ** |
|
allocation_tableau_noeuds(struct_processus *s_etat_processus) |
|
{ |
|
struct_arbre_variables **objet; |
|
|
|
if ((*s_etat_processus).pointeur_variables_tableau_noeuds > 0) |
|
{ |
|
objet = (*s_etat_processus).variables_tableau_noeuds |
|
[--(*s_etat_processus).pointeur_variables_tableau_noeuds]; |
|
} |
|
else |
|
{ |
|
objet = malloc((*s_etat_processus).nombre_caracteres_variables |
|
* sizeof(struct_arbre_variables *)); |
|
} |
|
|
|
return(objet); |
|
} |
|
|
|
static inline void |
|
liberation_tableau_noeuds(struct_processus *s_etat_processus, |
|
struct_arbre_variables **objet) |
|
{ |
|
if ((*s_etat_processus).pointeur_variables_tableau_noeuds < TAILLE_CACHE) |
|
{ |
|
(*s_etat_processus).variables_tableau_noeuds |
|
[(*s_etat_processus).pointeur_variables_tableau_noeuds++] = |
|
objet; |
|
} |
|
else |
|
{ |
|
free(objet); |
|
} |
|
|
|
return; |
|
} |
|
|
|
static inline struct_liste_variables * |
|
allocation_feuille(struct_processus *s_etat_processus) |
|
{ |
|
struct_liste_variables *objet; |
|
|
|
if ((*s_etat_processus).pointeur_variables_feuille > 0) |
|
{ |
|
objet = (*s_etat_processus).variables_feuille |
|
[--(*s_etat_processus).pointeur_variables_feuille]; |
|
} |
|
else |
|
{ |
|
objet = malloc(sizeof(struct_liste_variables)); |
|
} |
|
|
|
return(objet); |
|
} |
|
|
|
static inline void |
|
liberation_feuille(struct_processus *s_etat_processus, |
|
struct_liste_variables *objet) |
|
{ |
|
if ((*s_etat_processus).pointeur_variables_feuille < TAILLE_CACHE) |
|
{ |
|
(*s_etat_processus).variables_feuille |
|
[(*s_etat_processus).pointeur_variables_feuille++] = objet; |
|
} |
|
else |
|
{ |
|
free(objet); |
|
} |
|
|
|
return; |
|
} |
|
|
|
static inline struct_variable * |
|
allocation_variable(struct_processus *s_etat_processus) |
|
{ |
|
struct_variable *objet; |
|
|
|
if ((*s_etat_processus).pointeur_variables_variable > 0) |
|
{ |
|
objet = (*s_etat_processus).variables_variable |
|
[--(*s_etat_processus).pointeur_variables_variable]; |
|
} |
|
else |
|
{ |
|
objet = malloc(sizeof(struct_variable)); |
|
} |
|
|
|
return(objet); |
|
} |
|
|
|
static inline void |
|
liberation_variable(struct_processus *s_etat_processus, |
|
struct_variable *objet) |
|
{ |
|
if ((*s_etat_processus).pointeur_variables_variable < TAILLE_CACHE) |
|
{ |
|
(*s_etat_processus).variables_variable |
|
[(*s_etat_processus).pointeur_variables_variable++] = objet; |
|
} |
|
else |
|
{ |
|
free(objet); |
|
} |
|
|
return; |
return; |
} |
} |
Line 226 ajout_variable(struct_processus *s_etat_
|
Line 419 ajout_variable(struct_processus *s_etat_
|
if ((*s_etat_processus).s_arbre_variables == NULL) |
if ((*s_etat_processus).s_arbre_variables == NULL) |
{ |
{ |
if (((*s_etat_processus).s_arbre_variables = |
if (((*s_etat_processus).s_arbre_variables = |
malloc(sizeof(struct_arbre_variables))) == NULL) |
allocation_noeud(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 238 ajout_variable(struct_processus *s_etat_
|
Line 431 ajout_variable(struct_processus *s_etat_
|
(*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL; |
(*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL; |
|
|
if (((*(*s_etat_processus).s_arbre_variables).noeuds = |
if (((*(*s_etat_processus).s_arbre_variables).noeuds = |
malloc((*s_etat_processus).nombre_caracteres_variables |
allocation_tableau_noeuds(s_etat_processus)) == NULL) |
* sizeof(struct_arbre_variables))) == NULL) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 258 ajout_variable(struct_processus *s_etat_
|
Line 450 ajout_variable(struct_processus *s_etat_
|
while((*ptr) != d_code_fin_chaine) |
while((*ptr) != d_code_fin_chaine) |
{ |
{ |
BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0, |
BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0, |
printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom, |
uprintf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom, |
*ptr)); |
*ptr)); |
|
|
if ((*l_variable_courante).noeuds[(*s_etat_processus) |
if ((*l_variable_courante).noeuds[(*s_etat_processus) |
Line 269 ajout_variable(struct_processus *s_etat_
|
Line 461 ajout_variable(struct_processus *s_etat_
|
|
|
if (((*l_variable_courante).noeuds[(*s_etat_processus) |
if (((*l_variable_courante).noeuds[(*s_etat_processus) |
.pointeurs_caracteres_variables[*ptr]] = |
.pointeurs_caracteres_variables[*ptr]] = |
malloc(sizeof(struct_arbre_variables))) == NULL) |
allocation_noeud(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 306 ajout_variable(struct_processus *s_etat_
|
Line 498 ajout_variable(struct_processus *s_etat_
|
|
|
if (((*(*l_variable_courante).noeuds[(*s_etat_processus) |
if (((*(*l_variable_courante).noeuds[(*s_etat_processus) |
.pointeurs_caracteres_variables[*ptr]]).noeuds = |
.pointeurs_caracteres_variables[*ptr]]).noeuds = |
malloc((*s_etat_processus).nombre_caracteres_variables |
allocation_tableau_noeuds(s_etat_processus)) == NULL) |
* sizeof(struct_arbre_variables))) == NULL) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 334 ajout_variable(struct_processus *s_etat_
|
Line 525 ajout_variable(struct_processus *s_etat_
|
// variables de même nom. Cette liste boucle en premier lieu sur |
// variables de même nom. Cette liste boucle en premier lieu sur |
// elle-même. |
// elle-même. |
|
|
if (((*l_variable_courante).feuille = malloc( |
if (((*l_variable_courante).feuille = allocation_feuille( |
sizeof(struct_liste_variables))) == NULL) |
s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
|
(*l_variable_courante).noeuds_utilises++; |
|
|
(*(*l_variable_courante).feuille).suivant = |
(*(*l_variable_courante).feuille).suivant = |
(*l_variable_courante).feuille; |
(*l_variable_courante).feuille; |
(*(*l_variable_courante).feuille).precedent = |
(*(*l_variable_courante).feuille).precedent = |
Line 351 ajout_variable(struct_processus *s_etat_
|
Line 544 ajout_variable(struct_processus *s_etat_
|
// Allocation de la variable sur l'élément de la liste. |
// Allocation de la variable sur l'élément de la liste. |
|
|
if (((*(*l_variable_courante).feuille).variable = |
if (((*(*l_variable_courante).feuille).variable = |
malloc(sizeof(struct_variable))) == NULL) |
allocation_variable(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 363 ajout_variable(struct_processus *s_etat_
|
Line 556 ajout_variable(struct_processus *s_etat_
|
} |
} |
else |
else |
{ |
{ |
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) |
== NULL) |
== NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 380 ajout_variable(struct_processus *s_etat_
|
Line 573 ajout_variable(struct_processus *s_etat_
|
|
|
BUG((*(*(*l_variable_courante).feuille).variable).niveau >= |
BUG((*(*(*l_variable_courante).feuille).variable).niveau >= |
(*s_variable).niveau, |
(*s_variable).niveau, |
printf("Variable=\"%s\"\n", (*s_variable).nom)); |
uprintf("Variable=\"%s\"\n", (*s_variable).nom)); |
|
|
// On ajoute la variable à la liste existante. |
// On ajoute la variable à la liste existante. |
|
|
Line 396 ajout_variable(struct_processus *s_etat_
|
Line 589 ajout_variable(struct_processus *s_etat_
|
(*l_variable_courante).feuille = l_nouvelle_variable; |
(*l_variable_courante).feuille = l_nouvelle_variable; |
|
|
if (((*(*l_variable_courante).feuille).variable = |
if (((*(*l_variable_courante).feuille).variable = |
malloc(sizeof(struct_variable))) == NULL) |
allocation_variable(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 420 ajout_variable(struct_processus *s_etat_
|
Line 613 ajout_variable(struct_processus *s_etat_
|
|
|
BUG((*(*l_variable_candidate).variable).niveau == |
BUG((*(*l_variable_candidate).variable).niveau == |
(*s_variable).niveau, |
(*s_variable).niveau, |
printf("Variable=\"%s\"\n", (*s_variable).nom)); |
uprintf("Variable=\"%s\"\n", (*s_variable).nom)); |
|
|
l_variable_candidate = (*l_variable_candidate).precedent; |
l_variable_candidate = (*l_variable_candidate).precedent; |
} while((l_variable_candidate != (*l_variable_courante).feuille) && |
} while((l_variable_candidate != (*l_variable_courante).feuille) && |
((*(*l_variable_candidate).variable).niveau <= 1)); |
((*(*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) |
if ((*(*(*(*l_variable_courante).feuille).precedent).variable) |
.niveau > 1) |
.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 |
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) |
l_variable_candidate = (*(*l_variable_courante).feuille) |
.precedent; |
.precedent; |
} |
} |
Line 445 ajout_variable(struct_processus *s_etat_
|
Line 646 ajout_variable(struct_processus *s_etat_
|
(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; |
(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; |
(*l_variable_candidate).precedent = 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 = |
if (((*l_nouvelle_variable).variable = |
malloc(sizeof(struct_variable))) == NULL) |
allocation_variable(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 465 ajout_variable(struct_processus *s_etat_
|
Line 677 ajout_variable(struct_processus *s_etat_
|
{ |
{ |
// Le niveau courant n'existe pas. Il est créé. |
// Le niveau courant n'existe pas. Il est créé. |
|
|
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) |
== NULL) |
== NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 481 ajout_variable(struct_processus *s_etat_
|
Line 693 ajout_variable(struct_processus *s_etat_
|
|
|
// Ajout de la variable en tête de la liste |
// Ajout de la variable en tête de la liste |
|
|
if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) |
if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 499 ajout_variable(struct_processus *s_etat_
|
Line 711 ajout_variable(struct_processus *s_etat_
|
{ |
{ |
// Le niveau courant n'existe pas. Il est créé. |
// Le niveau courant n'existe pas. Il est créé. |
|
|
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) |
== NULL) |
== NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 521 ajout_variable(struct_processus *s_etat_
|
Line 733 ajout_variable(struct_processus *s_etat_
|
|
|
// Ajout de la variable en tête de la liste |
// Ajout de la variable en tête de la liste |
|
|
if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) |
if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 561 ajout_variable(struct_processus *s_etat_
|
Line 773 ajout_variable(struct_processus *s_etat_
|
|
|
if (niveau_acceptable == d_faux) |
if (niveau_acceptable == d_faux) |
{ |
{ |
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) |
== NULL) |
== NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 594 ajout_variable(struct_processus *s_etat_
|
Line 806 ajout_variable(struct_processus *s_etat_
|
|
|
// Ajout de la variable en tête de la liste l_variable_candidate. |
// Ajout de la variable en tête de la liste l_variable_candidate. |
|
|
if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) |
if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 608 ajout_variable(struct_processus *s_etat_
|
Line 820 ajout_variable(struct_processus *s_etat_
|
{ |
{ |
// Ajout de la variable en tête de la liste |
// Ajout de la variable en tête de la liste |
|
|
if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) |
if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 976 retrait_variable(struct_processus *s_eta
|
Line 1188 retrait_variable(struct_processus *s_eta
|
unsigned char *nom_variable, unsigned char type) |
unsigned char *nom_variable, unsigned char type) |
{ |
{ |
logical1 erreur; |
logical1 erreur; |
|
logical1 variable_supprimee; |
|
|
struct_arbre_variables *s_arbre_a_supprimer; |
struct_arbre_variables *s_arbre_a_supprimer; |
struct_arbre_variables *s_arbre_courant; |
struct_arbre_variables *s_arbre_courant; |
struct_arbre_variables *noeud_courant; |
|
|
|
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_precedent; |
struct_liste_chainee *l_element_precedent; |
Line 989 retrait_variable(struct_processus *s_eta
|
Line 1201 retrait_variable(struct_processus *s_eta
|
|
|
unsigned long niveau; |
unsigned long niveau; |
|
|
|
(*s_etat_processus).niveau_supprime = d_faux; |
|
|
if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) |
if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) |
{ |
{ |
// Une variable correspondant au nom recherché est accessible. |
// Une variable correspondant au nom recherché est accessible. |
Line 1069 retrait_variable(struct_processus *s_eta
|
Line 1283 retrait_variable(struct_processus *s_eta
|
|
|
variable_a_supprimer = (*s_etat_processus) |
variable_a_supprimer = (*s_etat_processus) |
.pointeur_feuille_courante; |
.pointeur_feuille_courante; |
s_arbre_courant = (*variable_a_supprimer).noeud_pere; |
s_arbre_courant = (*variable_a_supprimer).noeud; |
noeud_courant = (*variable_a_supprimer).noeud; |
|
(*s_arbre_courant).noeuds[(*noeud_courant).indice_tableau_pere] |
|
= NULL; |
|
|
|
BUG((*s_arbre_courant).noeuds_utilises == 0, |
BUG((*s_arbre_courant).noeuds_utilises == 0, |
uprintf("Freed node !\n")); |
uprintf("Freed node !\n")); |
(*s_arbre_courant).noeuds_utilises--; |
(*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) |
while((*s_arbre_courant).noeuds_utilises == 0) |
{ |
{ |
s_arbre_a_supprimer = s_arbre_courant; |
s_arbre_a_supprimer = s_arbre_courant; |
Line 1085 retrait_variable(struct_processus *s_eta
|
Line 1299 retrait_variable(struct_processus *s_eta
|
|
|
if (s_arbre_courant == NULL) |
if (s_arbre_courant == NULL) |
{ |
{ |
free((*s_arbre_a_supprimer).noeuds); |
liberation_tableau_noeuds(s_etat_processus, |
free(s_arbre_a_supprimer); |
(*s_arbre_a_supprimer).noeuds); |
|
liberation_noeud(s_etat_processus, s_arbre_a_supprimer); |
|
|
|
(*s_etat_processus).s_arbre_variables = NULL; |
break; |
break; |
} |
} |
|
|
Line 1100 retrait_variable(struct_processus *s_eta
|
Line 1317 retrait_variable(struct_processus *s_eta
|
(*s_arbre_courant).noeuds[(*s_arbre_a_supprimer) |
(*s_arbre_courant).noeuds[(*s_arbre_a_supprimer) |
.indice_tableau_pere] = NULL; |
.indice_tableau_pere] = NULL; |
|
|
free((*s_arbre_a_supprimer).noeuds); |
liberation_tableau_noeuds(s_etat_processus, |
free(s_arbre_a_supprimer); |
(*s_arbre_a_supprimer).noeuds); |
|
liberation_noeud(s_etat_processus, s_arbre_a_supprimer); |
|
|
BUG((*s_arbre_courant).noeuds_utilises == 0, |
BUG((*s_arbre_courant).noeuds_utilises == 0, |
uprintf("Freed node !\n")); |
uprintf("Freed node !\n")); |
Line 1142 retrait_variable(struct_processus *s_eta
|
Line 1360 retrait_variable(struct_processus *s_eta
|
(*(*s_etat_processus).pointeur_feuille_courante).suivant; |
(*(*s_etat_processus).pointeur_feuille_courante).suivant; |
(*s_etat_processus).pointeur_variable_courante = |
(*s_etat_processus).pointeur_variable_courante = |
(*(*s_etat_processus).pointeur_feuille_courante).variable; |
(*(*s_etat_processus).pointeur_feuille_courante).variable; |
|
|
noeud_courant = NULL; |
|
} |
} |
|
|
// Dans tous les cas, on retire la variable de la liste des variables |
// Dans tous les cas, on retire la variable de la liste des variables |
Line 1151 retrait_variable(struct_processus *s_eta
|
Line 1367 retrait_variable(struct_processus *s_eta
|
|
|
niveau = (*(*variable_a_supprimer).variable).niveau; |
niveau = (*(*variable_a_supprimer).variable).niveau; |
variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau; |
variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau; |
|
variable_supprimee = d_faux; |
|
|
if (variables_par_niveau != NULL) |
if (variables_par_niveau != NULL) |
{ |
{ |
Line 1188 retrait_variable(struct_processus *s_eta
|
Line 1405 retrait_variable(struct_processus *s_eta
|
(*l_element_courant).suivant; |
(*l_element_courant).suivant; |
} |
} |
|
|
free(l_element_courant); |
liberation_maillon(s_etat_processus, |
|
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; |
|
liberation_feuille(s_etat_processus, |
|
variables_par_niveau); |
|
} |
|
|
|
variable_supprimee = d_vrai; |
break; |
break; |
} |
} |
|
|
Line 1198 retrait_variable(struct_processus *s_eta
|
Line 1447 retrait_variable(struct_processus *s_eta
|
} |
} |
} |
} |
|
|
|
if (variable_supprimee == d_vrai) |
|
{ |
|
break; |
|
} |
|
|
variables_par_niveau = (*variables_par_niveau).suivant; |
variables_par_niveau = (*variables_par_niveau).suivant; |
|
|
} while(variables_par_niveau != (*s_etat_processus) |
} while(variables_par_niveau != (*s_etat_processus) |
Line 1208 retrait_variable(struct_processus *s_eta
|
Line 1462 retrait_variable(struct_processus *s_eta
|
|
|
free((*(*variable_a_supprimer).variable).nom); |
free((*(*variable_a_supprimer).variable).nom); |
liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet); |
liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet); |
free((*variable_a_supprimer).variable); |
liberation_variable(s_etat_processus, (*variable_a_supprimer).variable); |
free(variable_a_supprimer); |
liberation_feuille(s_etat_processus, variable_a_supprimer); |
|
|
erreur = d_absence_erreur; |
erreur = d_absence_erreur; |
|
|
if (noeud_courant != NULL) |
|
{ |
|
free((*noeud_courant).noeuds); |
|
free(noeud_courant); |
|
} |
|
} |
} |
else |
else |
{ |
{ |
Line 1280 retrait_variable_par_niveau(struct_proce
|
Line 1528 retrait_variable_par_niveau(struct_proce
|
while((*(*s_etat_processus).l_liste_variables_par_niveau).liste |
while((*(*s_etat_processus).l_liste_variables_par_niveau).liste |
!= NULL) |
!= NULL) |
{ |
{ |
|
// Nécessaire car le pointeur sur la tête de la pile |
|
// peut être modifié par retrait_variable(). |
// Sauvegarde des variables statiques. |
// Sauvegarde des variables statiques. |
|
|
if ((*((struct_variable *) (*(*(*s_etat_processus) |
if ((*((struct_variable *) (*(*(*s_etat_processus) |
Line 1367 retrait_variable_par_niveau(struct_proce
|
Line 1617 retrait_variable_par_niveau(struct_proce
|
{ |
{ |
return(d_erreur); |
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); |
|
} |
} |
} |
} |
} |
|
|
Line 1381 retrait_variable_par_niveau(struct_proce
|
Line 1642 retrait_variable_par_niveau(struct_proce
|
.l_liste_variables_par_niveau; |
.l_liste_variables_par_niveau; |
(*s_etat_processus).l_liste_variables_par_niveau = |
(*s_etat_processus).l_liste_variables_par_niveau = |
(*l_element_a_supprimer).suivant; |
(*l_element_a_supprimer).suivant; |
free(l_element_a_supprimer); |
liberation_feuille(s_etat_processus, l_element_a_supprimer); |
} |
} |
|
|
return(d_absence_erreur); |
return(d_absence_erreur); |
Line 1417 liberation_arbre_variables(struct_proces
|
Line 1678 liberation_arbre_variables(struct_proces
|
// pas détruit par cette opération, il sera détruit lors de la libération |
// pas détruit par cette opération, il sera détruit lors de la libération |
// de la liste des variables par niveau. |
// de la liste des variables par niveau. |
|
|
|
if (arbre == NULL) |
|
{ |
|
return; |
|
} |
|
|
l_element_courant = (*arbre).feuille; |
l_element_courant = (*arbre).feuille; |
|
|
if (l_element_courant != NULL) |
if (l_element_courant != NULL) |
Line 1424 liberation_arbre_variables(struct_proces
|
Line 1690 liberation_arbre_variables(struct_proces
|
do |
do |
{ |
{ |
l_element_suivant = (*l_element_courant).suivant; |
l_element_suivant = (*l_element_courant).suivant; |
free(l_element_courant); |
liberation_feuille(s_etat_processus, l_element_courant); |
l_element_courant = l_element_suivant; |
l_element_courant = l_element_suivant; |
} while(l_element_courant != (*arbre).feuille); |
} while(l_element_courant != (*arbre).feuille); |
|
|
|
(*arbre).feuille = NULL; |
} |
} |
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
Line 1435 liberation_arbre_variables(struct_proces
|
Line 1703 liberation_arbre_variables(struct_proces
|
{ |
{ |
liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], |
liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], |
retrait_definitions); |
retrait_definitions); |
|
(*arbre).noeuds[i] = NULL; |
} |
} |
} |
} |
|
|
Line 1460 liberation_arbre_variables(struct_proces
|
Line 1729 liberation_arbre_variables(struct_proces
|
(*l_element_courant_liste).donnee)).objet); |
(*l_element_courant_liste).donnee)).objet); |
free((*((struct_variable *) (*l_element_courant_liste) |
free((*((struct_variable *) (*l_element_courant_liste) |
.donnee)).nom); |
.donnee)).nom); |
free((*l_element_courant_liste).donnee); |
|
} |
} |
|
|
l_element_suivant_liste = |
l_element_suivant_liste = |
(*l_element_courant_liste).suivant; |
(*l_element_courant_liste).suivant; |
free(l_element_courant_liste); |
liberation_variable(s_etat_processus, (struct_variable *) |
|
(*l_element_courant_liste).donnee); |
|
liberation_maillon(s_etat_processus, |
|
l_element_courant_liste); |
l_element_courant_liste = l_element_suivant_liste; |
l_element_courant_liste = l_element_suivant_liste; |
} |
} |
|
|
l_element_suivant = (*l_element_courant).suivant; |
l_element_suivant = (*l_element_courant).suivant; |
free(l_element_courant); |
liberation_feuille(s_etat_processus, l_element_courant); |
l_element_courant = l_element_suivant; |
l_element_courant = l_element_suivant; |
} while(l_element_courant != (*s_etat_processus) |
} while(l_element_courant != (*s_etat_processus) |
.l_liste_variables_par_niveau); |
.l_liste_variables_par_niveau); |
} |
} |
} |
} |
|
|
free((*arbre).noeuds); |
liberation_tableau_noeuds(s_etat_processus, (*arbre).noeuds); |
free(arbre); |
liberation_noeud(s_etat_processus, arbre); |
|
arbre = NULL; |
|
|
return; |
return; |
} |
} |
Line 1585 liste_variables(struct_processus *s_etat
|
Line 1857 liste_variables(struct_processus *s_etat
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
struct_arbre_variables * |
void |
copie_arbre_variables(struct_processus *s_etat_processus) |
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 |
// Les définitions sont partagées entre tous les threads et ne sont pas |
// copiées. |
// copiées. |
// |
// |
// NB : on ne copie que les variables de niveaux 0 et 1, les autres |
// 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 |
// 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; |
} |
} |
|
|
|
|