version 1.35, 2011/06/20 17:54:15
|
version 1.39, 2011/06/21 15:26:29
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.0.prerelease.1 |
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) |
if ((*s_etat_processus).l_liste_variables_par_niveau == NULL) |
{ |
{ |
printf("===========================================================\n"); |
printf("==========================================================" |
|
"======================\n"); |
return; |
return; |
} |
} |
|
|
Line 68 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 93 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 105 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 184 liste_variables_tas(struct_processus *s_
|
Line 188 liste_variables_tas(struct_processus *s_
|
} while((*arbre).feuille != l); |
} while((*arbre).feuille != l); |
} |
} |
|
|
printf("-----------------------------------------------------------\n"); |
printf("----------------------------------------------------------" |
|
"----------------------\n"); |
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
{ |
{ |
Line 204 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; |
return; |
} |
} |
Line 1040 retrait_variable(struct_processus *s_eta
|
Line 1048 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 1120 retrait_variable(struct_processus *s_eta
|
Line 1130 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; |
s_arbre_courant = (*variable_a_supprimer).noeud; |
BUG((*s_arbre_courant).noeuds_utilises == 0, |
BUG((*s_arbre_courant).noeuds_utilises == 0, |
uprintf("Freed node !\n")); |
uprintf("Freed node !\n")); |
Line 1245 retrait_variable(struct_processus *s_eta
|
Line 1254 retrait_variable(struct_processus *s_eta
|
|
|
if ((*variables_par_niveau).liste == NULL) |
if ((*variables_par_niveau).liste == NULL) |
{ |
{ |
|
(*s_etat_processus).niveau_supprime = |
|
d_vrai; |
|
|
if ((*s_etat_processus) |
if ((*s_etat_processus) |
.l_liste_variables_par_niveau |
.l_liste_variables_par_niveau |
== variables_par_niveau) |
== variables_par_niveau) |
Line 1524 liberation_arbre_variables(struct_proces
|
Line 1536 liberation_arbre_variables(struct_proces
|
free(l_element_courant); |
free(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 1532 liberation_arbre_variables(struct_proces
|
Line 1546 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 1557 liberation_arbre_variables(struct_proces
|
Line 1572 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).donnee); |
free(l_element_courant_liste); |
free(l_element_courant_liste); |
l_element_courant_liste = l_element_suivant_liste; |
l_element_courant_liste = l_element_suivant_liste; |
} |
} |
Line 1576 liberation_arbre_variables(struct_proces
|
Line 1591 liberation_arbre_variables(struct_proces
|
|
|
free((*arbre).noeuds); |
free((*arbre).noeuds); |
free(arbre); |
free(arbre); |
|
arbre = NULL; |
|
|
return; |
return; |
} |
} |
Line 1682 liste_variables(struct_processus *s_etat
|
Line 1698 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; |
} |
} |
|
|
|
|